Ciclo diário do desenvolvedor: Commit, Push e .gitignore

1. Primeiros passos: clonando o projeto

Vamos começar de onde paramos na aula anterior. Você tem um repositório criado no GitHub e agora precisa obter uma cópia local no seu computador para começar a trabalhar. Esse processo se chama clonagem.

Passo 1. Inicie sua IDE. Se algum projeto estiver aberto, feche-o por File -> Close Project. Na tela inicial, escolha Clone Repository ou Get from VCS.

Passo 2. Na janela que abrir, cole a URL do seu repositório. Esse método é útil se você estiver clonando o repositório de outra pessoa. A URL pode ser copiada da página do repositório no GitHub.

Se você estiver clonando o seu próprio repositório (nosso caso), o mais simples é entrar na sua conta do GitHub diretamente pela IDE. Para isso, selecione a opção Log in to GitHub. Sua IDE abrirá o navegador para autorização.

Na página que abrir, clique no botão verde Authorize JetBrains. Depois disso, você poderá escolher seus repositórios diretamente na lista da IDE. Selecione o projeto necessário e clique em Clone.

Passo 3. Sua IDE vai perguntar se você confia neste projeto. Como é o seu próprio repositório, clique em Trust Project.

Passo 4. Configuração do antivírus (para usuários do Windows)

O antivírus do Windows pode avisar que a IDE está tentando executar ações desconhecidas para ele. Como vamos criar e executar programas, precisamos permitir que a IDE funcione sem restrições. Clique no botão “Automatically”, para que a IDE adicione sozinha as pastas necessárias às exceções do antivírus.

2. Salvando alterações: Commit

commit — é um “instantâneo” (snapshot), ou o estado salvo do seu projeto em um determinado momento. Pense nele como um ponto de salvamento em um jogo: você sempre pode voltar a ele se algo der errado. Cada commit tem um identificador único e uma mensagem que descreve as alterações realizadas.

        gitGraph
        commit id: "Initial commit"
        commit id: "Add user authentication"
        commit id: "Fix login button bug"
        commit id: "Refactor database connection"
    

Histórico de commits. Cada novo commit é construído com base no anterior, criando uma cronologia da evolução do projeto.

Passo 1. Faça alterações.

Se você clonou um repositório recém-criado, ele conterá apenas um arquivo — README.md

Abra o arquivo README.md e adicione a descrição do seu projeto. Assim que começar a editar o arquivo, a IDE destacará seu nome em azul no painel do projeto. Isso significa que o arquivo foi modificado, mas as alterações ainda não foram salvas no Git. A IDE adicionará uma linha verde onde você fez mudanças.

Passo 2. Abra a janela Commit.

À esquerda da IDE há a aba Commit. Ao abri-la, você verá todas as alterações prontas para salvar. Para o primeiro commit, essa janela merece atenção especial.

Vamos entender o que estamos vendo:

• Changes: aqui ficam os arquivos que já são rastreados pelo Git, mas foram modificados. No nosso caso, é o README.md, no qual adicionamos o plano do projeto.
• Unversioned Files: são arquivos novos que o Git vê na pasta do projeto, mas ainda não rastreia.

Pode surgir a pergunta: é necessário adicionar todos esses arquivos auxiliares ao repositório?

A boa notícia é que, quando criamos o repositório no GitHub, escolhemos um template .gitignore. Esse arquivo já contém regras que dizem ao Git para ignorar pastas ou arquivos desnecessários. Mas falaremos mais sobre isso no fim da aula.

Por enquanto, nossa tarefa para o primeiro commit — adicionar todos os arquivos principais do projeto ao histórico e escrever a própria mensagem do commit.

Passo 3. Faça o commit.

Clique no botão Commit. Pronto! Você salvou um “instantâneo” do seu projeto no repositório local. O arquivo voltará à cor normal.

3. Enviando alterações para o GitHub: Push

Seus commits, por enquanto, estão apenas no seu computador. Para compartilhá-los com a equipe ou armazená-los em um local confiável, é preciso enviá-los para o repositório remoto no GitHub.

        sequenceDiagram
        participant Repositório local (seu computador)
        participant Repositório remoto (GitHub)

        note over Repositório local (seu computador): Você fez um ou mais commits.
Eles existem apenas aqui.

        Repositório local (seu computador) ->> Repositório remoto (GitHub): git push (enviar commits)

        note over Repositório remoto (GitHub): Seus commits foram copiados
e salvos com segurança no servidor.
    

Passo 1. Clique no botão Push.

No canto superior direito da IDE há uma seta verde apontando para cima — é o botão Push. Clique nele.

Passo 2. Revise e confirme.

Será aberta uma janela com todos os commits prontos para envio. Essa é sua última chance de garantir que você está enviando exatamente o que precisa. Clique em Push.

Se tudo ocorreu bem, você verá as mensagens: Pushed commits to origin/main. Create pull request

Passo 3. Verifique o resultado no GitHub.

Após o envio bem-sucedido, abra a página do seu repositório no GitHub. Você verá que suas alterações apareceram lá.

4. Painel do Git

Na sua IDE há um menu específico Git, que você encontra na barra superior. É o seu centro de controle de versões. Vamos conhecer rapidamente seus itens principais.

• Commit: abre a janela já conhecida para salvar alterações.
• Push: abre a janela para enviar seus commits ao GitHub.
• Update Project: função muito importante. Ela baixa as alterações mais recentes de outros membros da equipe (executa git pull). Clique nela todas as manhãs antes de começar a trabalhar!
• Branches: abre a janela para gerenciar branches. Vamos nos aprofundar nisso na próxima aula.
• Show Git Log: mostra todo o histórico de commits do seu projeto. Sua máquina do tempo pessoal.

5. Uso de arquivos .gitignore

Se você adicionou ao seu projeto alguns arquivos auxiliares e não quer que eles acabem no repositório, pode adicioná-los às exceções. Para isso existe um arquivo chamado .gitignore. É muito útil quando há arquivos que não precisam ser armazenados no sistema de controle de versão (por exemplo, arquivos temporários, logs, senhas).

Passo 1. Primeiro, crie um arquivo no diretório do projeto que você deseja ignorar. Por exemplo, notes.txt. Após criar o arquivo, clique em Cancel caso a IDE proponha adicioná-lo ao Git.

Passo 2. Clique com o botão direito do mouse no arquivo criado na janela “Project”. Vá até Git --> Add to .gitignore --> Add to .gitignore. Essa opção adiciona o arquivo selecionado ao arquivo .gitignore na raiz do seu projeto.

Se você ainda não tiver um arquivo .gitignore, a IDE vai sugerir criá-lo. Aceite.

Passo 3. Sua IDE adicionará automaticamente o nome do arquivo ao .gitignore.

Depois de adicionados ao .gitignore, os arquivos ignorados serão exibidos em cinza ou marrom. Ao tentar fazer commit, esses arquivos serão ignorados. A pasta .idea pode ser adicionada ao ignore.

Não se esqueça de fazer commit do próprio arquivo .gitignore no repositório e enviar as alterações ao GitHub, para que todos os participantes do projeto usem as mesmas regras de ignore.

Excluindo arquivos locais: .git/info/exclude

Além do arquivo .gitignore, que é usado para excluir arquivos para todos os usuários do projeto, o Git oferece a possibilidade de criar regras locais de ignore no arquivo .git/info/exclude. Elas não serão registradas no repositório e valerão apenas para a sua cópia local do projeto.

Isso pode ser útil, por exemplo, para ignorar arquivos criados pela sua IDE que não devem ir para o controle de versão, mas são específicos apenas para você.

Importante! As regras locais de ignore valem apenas para a sua cópia local do repositório.

E se eu já tiver feito commit?

O .gitignore ignora apenas arquivos novos, ainda não rastreados. Se você já fez commit de um arquivo, ele está no histórico do repositório, e o Git continuará rastreando-o mesmo que você o adicione ao .gitignore. Para essas situações, existe um comando no terminal: git rm --cached <file>. Mas é algo para estudar separadamente.

Regras para o .gitignore

No arquivo .gitignore são especificados padrões de nomes de arquivos e pastas que o Git deve ignorar.

Linhas vazias são ignoradas. Para adicionar um comentário, comece a linha com o caractere #.

Padrões:

• * — substitui qualquer quantidade de quaisquer caracteres. Por exemplo, *.log ignora todos os arquivos com a extensão .log.
• / — no final do padrão indica um diretório. Por exemplo, logs/ ignora todo o conteúdo da pasta logs.
• ! — no início da linha inverte a regra. Por exemplo, se você tem a regra *.log, mas quer rastrear important.log, adicione a linha !important.log.
• ** — corresponde a qualquer quantidade de pastas aninhadas. Por exemplo, **/temp ignora pastas temp em qualquer nível de profundidade.

Exemplo de arquivo .gitignore

# Código compilado
/bin/
/obj/

# Arquivos temporários
*.tmp
*.swp

# Logs
*.log

# Pastas criadas pela IDE
.idea/
*.user
*.suo

# Ambientes virtuais e dependências
/venv/
/node_modules/

Modelos prontos

Você não precisa escrever esses arquivos do zero. Existem modelos prontos, validados pela comunidade:

1. Coleção de .gitignore do GitHub para diferentes linguagens e frameworks: https://github.com/github/gitignore.
2. gitignore.io — serviço web prático que gera um arquivo .gitignore para as suas tecnologias.