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

1. Começando: 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 pra começar a trabalhar. Esse processo se chama clonar.

Passo 1. Abra sua IDE. Se algum projeto estiver aberto, feche ele via 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 jeito é útil quando você está clonando o repositório de outra pessoa. A URL pode ser copiada da página do repositório no GitHub.

Se você está clonando seu próprio repositório (nosso caso), o jeito mais simples é logar na sua conta do GitHub direto da IDE. Pra isso escolha a opção Log in to GitHub. Sua IDE vai abrir o navegador pra autenticação.

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

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

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

O antivírus do Windows pode avisar que a IDE está tentando executar ações desconhecidas. Como vamos criar e rodar programas, é preciso permitir que a IDE trabalhe sem restrições. Clique no botão "Automatically", para que a IDE adicione automaticamente as pastas necessárias às exceções do antivírus.

2. Salvando mudanças: Commit

commit é um "snapshot", ou estado salvo do seu projeto em um dado momento. Pense nisso como um ponto de save num jogo: você sempre pode voltar pra ele se algo der errado. Cada commit tem um identificador único e uma mensagem descrevendo as mudanças feitas.

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

História de commits. Cada novo commit se baseia no anterior, criando a cronologia do desenvolvimento do projeto.

Passo 1. Faça mudanças.

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

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

Passo 2. Abra a janela de Commit.

No canto esquerdo da IDE tem a aba Commit. Ao abrir você verá todas as mudanças prontas pra salvar. Pro primeiro commit essa janela merece atenção especial.

Vamos ver o que aparece:

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

Pode surgir a dúvida: preciso adicionar todos aqueles arquivos de serviço ao repositório?

Boa notícia: quando criamos o repositório no GitHub, escolhemos um template de .gitignore. Esse arquivo já tem regras dizendo pro Git ignorar pastas ou arquivos desnecessários. Mas a gente vai falar mais disso no final da aula.

Por enquanto, a tarefa pro primeiro commit é adicionar os arquivos principais do projeto ao histórico e escrever a mensagem do commit.

Passo 3. Faça o commit.

Clique no botão Commit. Pronto! Você salvou um "snapshot" do seu projeto no repositório local. O arquivo volta a cor normal.

3. Enviando mudanças pro GitHub: Push

Seus commits por enquanto estão só no seu computador. Pra compartilhar com a equipe ou guardar em um lugar seguro, é preciso enviar eles pro 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 só aqui.

        Repositório Local (Seu computador) ->> Repositório Remoto (GitHub): git push (enviar commits)

        note over Repositório Remoto (GitHub): Seus commits são copiados
e salvos com segurança no servidor.
    

Passo 1. Clique no botão Push.

No canto superior direito da IDE tem uma seta verde pra cima — esse é o botão Push. Clique nele.

Passo 2. Verifique e confirme.

A janela que abrir vai mostrar todos os commits prontos pra envio. É sua última chance de checar se você está enviando o que precisa. Clique em Push.

Se deu certo, você verá mensagens: Pushed commits to origin/main. Create pull request

Passo 3. Verifique no GitHub.

Depois do push bem-sucedido, abra a página do seu repositório no GitHub. Você vai ver que suas mudanças apareceram lá.

4. Painel de controle do Git

Na sua IDE existe um menu especial Git na barra superior. É o seu centro de controle de versionamento. Vamos ver rapidamente os itens principais.

• Commit: abre a janela que já conhecemos pra salvar mudanças.
• Push: abre a janela pra enviar seus commits pro GitHub.
• Update Project: função muito importante. Ela baixa mudanças recentes de outros membros da equipe (faz um git pull). Use todo começo de manhã antes de começar a trabalhar!
• Branches: abre a janela pra gerenciar branches. Vamos ver isso em detalhe na próxima aula.
• Show Git Log: mostra todo o histórico de commits do projeto. Sua máquina do tempo pessoal.

5. Usando arquivos .gitignore

Se você adicionou arquivos de serviço ao projeto e não quer que eles entrem acidentalmente no repositório, pode colocá-los em exclusão. Pra isso existe o arquivo chamado .gitignore. Isso é bem útil quando o projeto tem arquivos que não precisam ficar no controle de versão (por exemplo, arquivos temporários, logs, senhas).

Passo 1. Primeiro crie o arquivo na pasta do projeto que você quer ignorar. Por exemplo, notes.txt. Depois de criar, clique em Cancel se a IDE sugerir adicioná-lo ao Git.

Passo 2. Clique com o botão direito no arquivo criado na janela "Project". Vá em 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 oferecer criá-lo. Aceite.

Passo 3. A IDE vai adicionar automaticamente o nome do arquivo no .gitignore.

Depois de adicionar no .gitignore, os arquivos ignorados vão aparecer em cinza ou marrom. Ao tentar commitar, esses arquivos serão ignorados. A pasta .idea pode ser adicionada ao ignore.

Não esqueça de commitar o próprio arquivo .gitignore no repositório e enviar as mudanças pro GitHub, assim todo mundo no projeto usa as mesmas regras de ignorar arquivos.

Exceção de arquivos locais: .git/info/exclude

Além do arquivo .gitignore, que funciona pra todos os usuários do projeto, o Git permite criar regras locais de ignorar em .git/info/exclude. Elas não serão committadas pro repositório e valem só pra sua cópia local.

Isso é útil, por exemplo, pra ignorar arquivos criados pela sua IDE que não devem entrar no controle de versão, mas que são específicos só pra você.

Importante! Regras locais de ignorar valem apenas pra sua cópia local do repositório.

E se eu já commitei?

.gitignore ignora apenas arquivos novos, que ainda não estão sendo rastreados. Se você já commitou um arquivo, ele está na história do repositório, e o Git vai continuar rastreando ele mesmo que você adicione no .gitignore. Pra esses casos existe um comando de terminal: git rm --cached <file>. Mas sobre isso você vai ler separadamente.

Regras para .gitignore

No arquivo .gitignore você coloca padrões de nomes de arquivos e pastas que o Git deve ignorar.

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

Padrões:

• * — substitui qualquer número de qualquer caracteres. Por exemplo, *.log ignora todos os arquivos com extensão .log.
• / — no final do padrão indica 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 *.log mas quer rastrear important.log, adicione a linha !important.log.
• ** — corresponde a qualquer número de subpastas. Por exemplo, **/temp ignora pastas temp em qualquer nível de profundidade.

Exemplo de arquivo .gitignore

# Skompilirovannyy kod
/bin/
/obj/

# Vremennye fayly
*.tmp
*.swp

# Logy
*.log

# Papky, sozdayemye IDE
.idea/
*.user
*.suo

# Virtualnye okruzheniya i zavisimosti
/venv/
/node_modules/

Templates prontos

Você não precisa escrever esses arquivos do zero. Existem templates prontos e testados pela comunidade:

1. Coletânea de .gitignore do GitHub para várias linguagens e frameworks: https://github.com/github/gitignore.
2. gitignore.io — um serviço web prático que gera um arquivo .gitignore conforme suas tecnologias.