Git Commit: uma aula magistral

Um requisito básico de qualquer sistema de controle de versão é armazenar diferentes versões de arquivos para você. No Git, o comando que faz isso é commit . Aqui está tudo o que você precisa saber.

O que é um commit no Git?

Commits são as séries de instantâneos feitos ao longo do ciclo de vida de um projeto que compõem seu histórico de desenvolvimento. Commits são o que nos permite extrair uma versão do projeto como era em diferentes pontos no passado. Por que isso é importante?

Os sistemas de controle de versão (VCSs) são mais comumente usados ​​com código-fonte de software e projetos de desenvolvimento. Mas eles podem ser usados ​​com sucesso com qualquer coleção de arquivos de texto, como arquivos Markdown contendo capítulos de um livro.

Você pode não querer que todos os arquivos em seus diretórios de projeto sejam manipulados pelo VCS, então você precisa ser capaz de nomear os arquivos que deseja que sejam controlados por versão. Isso os adiciona à exibição de controle de versão do projeto. Eles serão monitorados quanto a mudanças.

Outra maneira de conseguir isso é usar uma lista de ignorados. Isso informa ao Git quais arquivos, diretórios ou tipos de arquivos ele deve sempre ignorar.

Com o tempo, à medida que novos arquivos são adicionados ao projeto, alguns precisarão ser adicionados ao sistema de controle de versão. No Git, isso é tratado pelo comando add . Na verdade, o comando add faz serviço duplo, como veremos.

Para manter um histórico das mudanças que foram feitas no projeto, você pedirá periodicamente ao Git para armazenar um instantâneo do estado do projeto, usando o comando commit . É aqui que o comando add reaparece em nosso fluxo de trabalho. Usamos o comando add para informar ao Git quais arquivos alterados queremos incluir no instantâneo. Em seguida, usamos commit para dizer ao Git para criar o instantâneo.

Configurando o comando commit

As informações sobre o commit são armazenadas com ele, para que seja sempre possível saber quem fez o commit, quando e o que o commit contém. Alguns desses metadados são capturados no momento do commit, como a mensagem de commit.

Os metadados relativos à identidade dos membros da equipe de desenvolvimento podem ser configurados por cada usuário, para evitar o fornecimento repetido da mesma informação.

Para definir seu nome globalmente para todos os repositórios em seu computador, use este comando.

 git config --global user.name "Dave McKay" 

Para verificar se seu nome foi definido, use este comando.

 git config --global user.name 

Se você precisar usar um nome diferente em um determinado repositório, mude para o diretório do projeto e use o mesmo comando sem a opção --global .

 git config user.name "McKay, David"

 git config user.name 

Agora temos um nome de usuário padrão diferente para este repositório e nosso nome global ainda é usado para outros repositórios.

De maneira semelhante, podemos definir um endereço de e-mail globalmente ou para um único repositório incluindo ou omitindo a opção --global .

 git config user.email "[email protected]"

 git config --global user.email "[email protected]"

 git config user.email

 git config --global user.email 

Essas configurações são mantidas em arquivos de configuração. As configurações globais do Git são mantidas em “~/.gitconfig” e as configurações específicas do repositório são mantidas no arquivo “.git/config” do repositório.

O comando commit faz referência e usa esses valores à medida que opera.

Usando o comando commit

O uso básico do comando commit é pegar os arquivos que estão na área de staging, conhecida como índice, e armazená-los como um commit no branch atual do repositório.

Um compromisso básico

Temos um projeto com um arquivo alterado. Usaremos o comando add para preparar o arquivo e, em seguida, confirmá-lo. Estamos usando a opção -m (mensagem de commit) para que possamos fornecer uma breve descrição do propósito das alterações. Se não usarmos essa opção, será solicitada uma mensagem de confirmação à medida que a confirmação ocorre. É mais conveniente adicionar um na linha de comando.

 git add jibber.c

 git commit -m "Texto de ajuda atualizado" 

Se usarmos o comando git log podemos revisar os detalhes dos commits, em ordem cronológica, com o commit mais recente no topo da lista.

 git log 

Os commits são exibidos em less .

O commit foi marcado com o nome e o endereço de e-mail que fornecemos anteriormente, e nossa mensagem de commit também está registrada.

Arquivos de preparo automático

A preparação de muitos arquivos pode demorar um pouco. Uma abordagem diferente é usar a opção -A (all) com add .

Isso organiza automaticamente todos os arquivos modificados junto com todos os arquivos atualmente não rastreados . A preparação de arquivos não rastreados respeita as configurações em seu arquivo “.gitignore”. O Git não testará os arquivos que você disse que não deseja incluir. Por fim, os arquivos no índice que não estão mais no diretório de trabalho são removidos do índice.

Claramente, a opção -A pode fazer com que muitas coisas aconteçam de uma só vez. A opção --dry-run fornece uma visualização das alterações sem realizá-las.

 git add -A --dry-run 

Em nosso exemplo, ele preparará dois arquivos existentes modificados e dois novos arquivos. Vamos usar a opção -A antes de usar o comando commit .

 git add -A

 git commit -m "Análise aprimorada" 

Podemos ver que ao todo quatro arquivos foram alterados. Dois deles são os arquivos recém-criados, que estão listados.

Encenação e Compromisso ao Mesmo Tempo

O comando commit tem uma opção -a (all) em letras minúsculas. Isso executa a preparação e a confirmação de arquivos em uma etapa.

A opção commit -a organiza e confirma arquivos existentes modificados e remove arquivos do índice se eles tiverem sido removidos de seu diretório de trabalho. Ele não prepara automaticamente arquivos não rastreados.

Como o comando add , o comando commit tem uma opção --dry-run que permite que você visualize suas ações antes de executá-lo.

 git commit -a --dry-run 

Agora vamos executar o comando.

 git commit -a --dry-run 

Os arquivos são preparados e confirmados para nós.

Comprometendo-se com um ramo diferente

Se você fez algumas alterações nos arquivos em seu diretório de trabalho, percebe que não fez o checkout da ramificação correta, você precisa que suas alterações sejam confirmadas na ramificação correta sem afetar a ramificação atual.

O Git não tem um comando para confirmar em um branch diferente. Mas você pode corrigir essa situação com um pouco de destreza do Git.

Usaremos o comando Git stash para fazer uma cópia das alterações. Em seguida, verificaremos o branch correto e aplicaremos as alterações do stash. Para aplicar as alterações ocultas, estamos usando o comando pop em vez do comando apply . O comando pop aplica as alterações e também as remove do stash.

Fizemos algumas alterações no branch new-parser do nosso repositório. Eles deveriam ter sido feitos no ramo classic-parser .

 git stash

 analisador clássico git checkout

 git stash pop 

Agora podemos executar um commit e atualizar esta ramificação.

 git commit -a -m "Funções de pré-analisador adicionadas" 

Se retornarmos ao ramo new-parser podemos ver que ele está atualizado, o que significa que as alterações foram removidas de seu diretório de trabalho e seu repositório e arquivos estão sincronizados.

 git checkout novo analisador

 git status 

RELACIONADO: Como atualizar e manter ramificações separadas do Git

Fazendo alterações nos commits

Se você precisa melhorar sua mensagem de commit—talvez tenha notado um erro de digitação nela—ou você esqueceu de preparar um arquivo que deveria ter sido incluído no commit, você pode usar a opção --amend para consertar as coisas. A ressalva é que isso não deve ser usado em commits que foram enviados para um repositório remoto.

Em nossa última mensagem de commit, “fraze” deveria ser “phrase”. Se usarmos git log podemos ver isso.

Para corrigir isso, usaremos a opção --amend assim.

 git commit --amend -m "Identificação de frase otimizada" 

Se usarmos git log mais uma vez, podemos ver que o commit antigo foi substituído por um novo com a mensagem de commit corrigida.

Se quisermos adicionar um arquivo que esquecemos de testar, podemos fazer o commit desse arquivo para que apareça como parte do commit anterior.

Usaremos add para preparar o arquivo e, em seguida, fazer um commit com a opção --amend . A opção --no-edit significa que não precisamos fornecer uma nova mensagem de confirmação. A mensagem de confirmação anterior é mantida.

 git add jibber.c

 git commit --amend --no-edit 

Removendo alterações de um commit

Se você inadvertidamente preparou e confirmou um arquivo que não pretendia, pode removê-lo da confirmação usando o comando reset . Vamos redefinir o commit de volta para a área de teste, ou index. Em seguida, removeremos o arquivo e confirmaremos novamente o restante dos arquivos.

Para redefinir o último commit para a área de preparação, usamos o comando reset --soft . HEAD~ é uma abreviação para “o commit atrás do HEAD da linha do tempo do commit do projeto”, ou em inglês, “the last commit”.

 git reset --soft HEAD~ 

Para remover o arquivo que não deveria ter sido incluído, usamos o comando reset --mixed . Isso redefine essas alterações de volta para o diretório de trabalho, recriando o arquivo modificado como um arquivo não confirmado e não testado.

 git reset --mixed jibber.c 

Precisamos confirmar os outros arquivos que restam no índice.

 git commit -m "Ajustes experimentais" 

Os outros dois arquivos que estavam no commit original foram confirmados novamente para nós.

RELACIONADO: Como corrigir, editar ou desfazer confirmações do Git (alterando o histórico do Git)

Revertendo um commit inteiro

Às vezes, desfazer um commit inteiro é a coisa mais fácil de fazer. Ele coloca seu diretório de trabalho e repositório de volta ao estado em que estavam antes do commit.

Precisamos usar o ID de referência com hash do commit. Podemos encontrar isso usando git log :

Copie essa referência e use-a no comando revert :

 git reverter e5bd4560aef8164c6ca9d6d4620b9db7f66aecc8 

Isso abrirá seu editor padrão para que você possa editar uma mensagem de reversão. Há uma mensagem padrão inserida para você. Você pode usar isso ou editá-lo ao seu gosto.

Quando estiver satisfeito com sua mensagem de reversão, salve o arquivo e saia do editor. No nano, você faz isso com “Ctrl+O” e “Ctrl+X”.

Usando git log mais uma vez, podemos ver que um novo commit foi adicionado que desfaz as alterações do commit revertido.

O canivete suíço Git

Obviamente, commit é um dos comandos Git mais importantes. Ele pode fazer muito, então há muito o que aprender. Conhecer seus recursos menos usados ​​é um tempo bem gasto. Quando você precisar corrigir um erro - agora mesmo - ficará feliz por ter se preparado com antecedência.

RELACIONADO: Como usar o Git merge