O comando git-commit é uma ferramenta fundamental no arsenal de qualquer desenvolvedor que utiliza versionamento de código. O comando representa o momento em que as alterações feitas em um repositório Git são registradas na linha do tempo do projeto, para depois serem sincronizadas com o seu repositório. Ao executar este comando, um commit é criado, guardando os arquivos modificados que você selecionou e uma mensagem descritiva que detalha as mudanças realizadas. Essa mensagem, além de documentar o propósito das alterações, é crucial para manter um histórico claro e compreensível do desenvolvimento do projeto.

Quando um novo commit é criado, ele se torna herdeiro direto do HEAD, que geralmente representa o último ponto do ramo em que estamos trabalhando. Garantindo a continuidade e organização do fluxo de trabalho.

Descrição

Há várias abordagens para definir o conteúdo a ser commitado:

1. Incrementar as mudanças com o git-add, para o índice, antes de usar o git-commit.
2. Remover os arquivos da árvore de trabalho do índice, com o comando git-rm, antes de usar o git-commit.
3. Listar os arquivos como argumentos para o git-commit, fazendo com que o commit ignore as alterações organizadas no índice e registre o conteúdo atual dos arquivos listados.
4. Utilizar -a para adicionar automaticamente as alterações de todos os arquivos informados.
5. Utilizar --interactive ou --patch para decidir um por um quais blocos de código ou arquivos vão fazer parte do commit.

Para obter um resumo do que está incluído no commit, utilize o comando --dry-run, e caso faça um commit e encontre um erro logo depois, é possível recuperá-lo com o comando git reset.

Documentação dos comandos citados:

git-add: https://git-scm.com/docs/git-add/pt_BR

git-rm: https://git-scm.com/docs/git-rm/pt_BR

git-reset: https://git-scm.com/docs/git-reset/pt_BR

Opções

O comando git-commit pode ser utilizado seguido de diversos outros comando auxiliares que desempenham diversas funções, desde personalizar mensagens de commit até manipular arquivos de forma precisa, essas opções oferecem controle adicional sobre o processo de gravação de alterações.

As opções para o comando git-commit são:

-a, --all: Instrui o comando a preparar automaticamente os arquivos modificados e excluídos para o commit. No entanto, os novos arquivos não informados ao Git não são afetados.

-p, --patch: Permite utilizar a interface interativa do patch para selecionar quais alterações serão incluídas no commit. Isso é útil para revisar e escolher as alterações desejadas antes de confirmar o commit.

-C <commit>, --reuse-message=<commit>: Reutiliza um commit existente, incluindo sua mensagem e informações de autoria, na criação de um novo commit.

-c <commit>, --reedit-message=<commit>: Similar a -C, mas permite editar ainda mais a mensagem do commit utilizando um editor.

--fixup=<commit>: Constrói a mensagem de um commit para utilização com rebase --autosquash, prefixando a mensagem com "fixup!".

--squash=<commit>: Constrói a mensagem de um commit para utilização com rebase --autosquash, prefixando a mensagem com "squash!".

--reset-author: Ao fazer um commit após uma escolha seletiva conflitante, declara que a autoria do commit resultante pertence a quem fez o commit originalmente.

--short: Ao executar um ensaio, exibe a saída no formato curto, implicando o uso da opção --dry-run.

--branch: Exibe informações sobre o ramo e o rastreamento quando estiver em formato curto.

--porcelain: Ao executar um ensaio, exibe a saída no formato porcelana, implicando o uso da opção --dry-run.

--long: Ao executar um ensaio, exibe a saída no formato longo, implicando o uso da opção --dry-run.

-z, --null: Ao exibir a saída no formato curto ou porcelana, imprime o nome do arquivo literalmente e termina as entradas com um NUL em vez de LF.

-F <arquivo>, --file=<arquivo>: Permite obter a mensagem de commit de um arquivo específico. O caractere '-' pode ser usado para ler a mensagem da entrada padrão.

--author=<autor>: Sobrescreve o autor do commit, permitindo definir explicitamente o autor no formato "Nome <email>".

--date=<data>: Substitui a data de autoria utilizada no commit.

-m <msg>, --message=<msg>: Utiliza a mensagem especificada como a mensagem do commit. Se múltiplas opções -m forem usadas, seus conteúdos serão dispostos em parágrafos separados.

-t <arquivo>, --template=<arquivo>: Ao editar a mensagem do commit, inicia o editor com o conteúdo do arquivo especificado, útil para fornecer orientações sobre a redação da mensagem.

-s, --signoff: Adiciona uma linha assinada pelo autor do commit ao final do registro log do commit.

-n, --no-verify: Ignora os ganchos dos commits anteriores e os ganchos das mensagens de commit.

--allow-empty: Permite fazer um commit mesmo que ele tenha exatamente a mesma árvore de origem, ignorando a segurança.

--allow-empty-message: Permite criar um commit com uma mensagem vazia.

--cleanup=<modo>: Determina como a mensagem do commit será limpa antes de ser feito o commit. As opções disponíveis incluem "strip", "whitespace", "verbatim", "scissors" e "default".

-e, --edit: Permite editar ainda mais a mensagem do commit obtida de diferentes fontes.

--no-edit: Utiliza a mensagem do commit selecionada sem abrir um editor.

--amend: Substitui o último commit criando um novo commit com a árvore preparada e a mensagem do commit original.

--no-post-rewrite: Ignora o gancho de reescrita de postagem.

-i, --include: Antes de fazer um commit dos conteúdos preparados, também prepara o conteúdo dos caminhos especificados na linha de comando.

-o, --only: Faz um commit utilizando apenas os conteúdos atualizados dos caminhos especificados, ignorando qualquer outro conteúdo preparado anteriormente.

--pathspec-from-file=<arquivo>: Passa o pathspec de um arquivo em vez dos argumentos da linha de comando.

--pathspec-file-nul: Só faz sentido em conjunto com --pathspec-from-file, separando os elementos do pathspec com caracteres NUL.

Exemplos

1 - Gravando alterações Básicas:

Quando você fez alterações em seus arquivos e está pronto para registrá-las, você pode usar o comando git commit sem nenhum parâmetro. Isso registrará todas as alterações preparadas até o momento. Exemplo:

$ edit hello.c
$ git rm goodbye.c
$ git add hello.c
$ git commit

2 - Gravando todas as alterações de uma vez:

Se você deseja gravar todas as alterações feitas em arquivos rastreados de uma só vez, pode usar a opção -a com o comando git commit. Isso executa automaticamente git add e git rm para os arquivos modificados e removidos. Exemplo:

$ edit hello.c
$ rm goodbye.c
$ git commit -a

3 - Gravando alterações em arquivos específicos:

Você também pode especificar quais arquivos deseja incluir no commit, encaminhando seus pathnames para o comando git commit. Isso permite que você selecione quais alterações serão registradas. Exemplo:

$ edit hello.c hello.h
$ git add hello.c hello.h
$ edit Makefile
$ git commit Makefile

4 - Resolvendo conflitos de mesclagem:

Após uma mesclagem que resulta em conflitos, os arquivos com conflitos são preparados para você resolver. Exemplo:

$ git status | grep unmerged
unmerged: hello.c
$ edit hello.c
$ git add hello.c
$ git commit

Informações do Commit

Quando você faz um commit no Git, o sistema precisa saber quem é o autor das mudanças e quem está realizando o commit. Essas informações são extraídas de variáveis de ambiente específicas, mas há algumas regras e práticas recomendadas a serem seguidas.

1 - Variáveis de ambiente:

• GIT_AUTHOR_NAME
• GIT_AUTHOR_EMAIL
• GIT_AUTHOR_DATE
• GIT_COMMITTER_NAME
• GIT_COMMITTER_EMAIL
• GIT_COMMITTER_DATE

2 - Convenções de nomenclatura:

O git não impõe nenhuma convenção específica, mas é recomendável não utilizar caracteres especiais que podem causar problemas no momento de armazenar essas informações.

3 - Obtenção de informações:

Se algumas dessas variáveis de ambiente não estiverem definidas, o Git tentará obter as informações dos itens de configuração user.name e user.email. Se esses não estiverem configurados, o Git verificará a variável de ambiente EMAIL. Caso contrário, o Git usará o nome de usuário do sistema e o nome do host como parte do email.

4 - Uso típico:

Geralmente, é suficiente definir apenas as variáveis user.name e user.email. As outras opções são mais úteis para casos de uso mais complexos, como quando você precisa especificar diferentes autores para diferentes partes de um projeto.

5 - Recomendação da mensagem de commit:

É uma prática recomendada iniciar a mensagem do commit com uma linha curta, resumindo a alteração, seguida por uma descrição mais detalhada. Essa primeira linha é tratada como o título do commit e é usada em todo o Git, incluindo em emails gerados pelo git-format-patch.

Conclusão

Em resumo, o comando git-commit é uma peça fundamental no fluxo de trabalho com versionamento de código Git, pois é utilizando esse comando que é feita a documentação de todas as alterações que ocorrem no projetos, através da visualização organizada das alterações e acompanhada das mensagens descritivas dos commits. Com uma série de opções e funcionalidades, o git commit oferece flexibilidade para adaptar o processo de commit às necessidades específicas de cada projeto e equipe.

Além disso, o git-commit desempenha um papel crucial na criação de pequenos backups de cada arquivo ao longo do desenvolvimento. Isso possibilita a revisão de alterações anteriores e a recuperação de código que foi modificado, oferecendo uma camada adicional de segurança e controle de versão.

Verifique a documentação completa do comando git-commit no link a seguir: https://git-scm.com/docs/git-commit/pt_BR