Usando o Git – parte 3

Git-3_gitignore

Na primeira parte foi apresentado o fluxo de trabalho e alguns conceitos básicos do Git, na segunda foi a vez de acrescentar o branch e também a “arte” de trazer arquivos de commits passados. Porém até o momento tivemos “sorte” em inserir os arquivos corretos e na hora certa dentro do repositório mas o que fazer quando algo dá errado e é necessário mexer na index ou mesmo da HEAD para corrigir o problema?

Nota : No meu planejamento nesta parte deveria ser a vez de tratar dos repositórios remotos e só me dei conta de que faltava isto aqui quando a parte dois já havia sido publicada… :-/

Antes de começar…

Como das outras vezes…

$ cd ~/Vagrant/usando_o_git
$ vagrant up --provider virtualbox
$ vagrant ssh

…iniciar a máquina virtual.

Apagando e renomeando arquivos

Apenas para relembrar que os arquivos no repositório da Pastelaria são estes aqui:

$ cd ~/pastelaria
$ ls -1
pastel_de_banana_com_canela.md
pastel_de_carne_com_ovo.md
pastel_de_carne.md
pastel_de_chocolate.md
pastel_de_frango_com_curry.md
pastel_de_queijo.md
README.md

Agora podemos tratar da lista de pedidos feitos pela gerência — que desta vez é até simples:

  • Trocar o nome do arquivo «pastel_de_carne.md» para «pastel_de_carne_moída.md»;
  • Criar o arquivo «sobremesas.md», deixá-lo em branco mas incluí-lo no repositório e
  • Remover os arquivos «pastel_de_carne_com_ovo.md» e «pastel_de_frango_com_curry.md» do repositório.

Então é renomear um arquivo:

$ mv pastel_de_carne.md pastel_de_carne_moída.md

Criar outro vazio:

$ touch sobremesas.md

E remover outros dois:

$ rm pastel_de_carne_com_ovo.md
$ rm pastel_de_frango_com_curry.md

Mas o  que acontece quando arquivos que são monitorados são apagados ou renomeados? Bem, basta usar git status para saber a resposta:

$ git status
On branch master
Changes not staged for commit:
  (use "git add/rm <file>..." to update what will be committed)
  (use "git checkout -- <file>..." to discard changes in working
  directory)

        deleted:    pastel_de_carne.md
        deleted:    pastel_de_carne_com_ovo.md
        deleted:    pastel_de_frango_com_curry.md

Untracked files:
  (use "git add <file>..." to include in what will be committed)

        "pastel_de_carne_mo\303\255da.md"
        sobremesas.md

no changes added to commit (use "git add" and/or "git commit -a")

Como a ferramenta não sabe que um arquivo foi renomeado ele o considera como também apagado e, ao mesmo tempo, informa o aparecimento de um novo no working directory e que não está sendo monitorando.

Assim é seguir com o resto dos procedimentos, primeiro adicionando os novos arquivos:

$ git add pastel_de_carne_moída.md
$ git add sobremesas.md

Retirar os demais:

$ git rm pastel_de_carne_com_ovo.md
$ git rm pastel_de_frango_com_curry.md

Detalhe que propositalmente eu não vou remover o «pastel _de_carne.md» ainda, vou deixá-lo quieto no repositório por enquanto. Ok?

E se algo der errado?

Relembrando algo da primeira parte:

Um detalhe importante, o Git não armazena automaticamente as modificações nos arquivos. Ele sabe que arquivos estão sendo criados, modificados e até apagados mas só fará algo se você “mandar”.

Isto vale tanto para o que está no working directory como também na staging area. Na primeira se trabalha normalmente enquanto que a outra é onde montamos o “roteiro” daquilo que precisará ser feito antes na execução de um novo commit.

Isto é muito útil pois a gerência (mais uma vez) mudou de ideia e pediu para não apagar os arquivos «pastel_de_carne_com_ovo.md» e «pastel_de_frango_com_curry.md», apenas retirá-los do rastreamento repositório. Mas acontece que há um pequenino detalhe agora, os arquivos já foram apagados:

$ ls -1
pastel_de_banana_com_canela.md
pastel_de_carne_moída.md
pastel_de_chocolate.md
pastel_de_queijo.md
README.md

E agora? A primeira coisa é trazê-los de volta do último commit:

$ git checkout master -- pastel_de_frango_com_curry.md
$ git checkout master -- pastel_de_carne_com_ovo.md

Se eu já não tivesse usado o git rm não precisaria especificar o ramo master no comando — repare na saída do git status que está mais acima de que são dadas duas opções com relação às mudanças detectadas: (1) usar add ou rm para definir o que será feito no commit  OU  (2) usar checkout para descartar o que foi mexido (no caso apagado).

Ajeitar a staging area retirando a remoção dos arquivos de lá:

$ git reset pastel_de_carne_com_ovo.md
$ git reset pastel_de_frango_com_curry.md

Informar ao Git para ignorá-los e acrescentá-los no arquivo «.gitignore»:

$ touch .gitignore
$ echo pastel_de_carne_com_ovo.md >> .gitignore
$ echo pastel_de_frango_com_curry.md >> .gitignore

Fazer o commit:

$ git commit -m "manutenção nos arquivos"
[master 0348067] manutenção nos arquivos
 2 files changed, 11 insertions(+)
 create mode 100644 "pastel_de_carne_mo\303\255da.md"
 create mode 100644 sobremesas.md

Opa, esqueci de incluir o «.gitignore» no repositório — pois é, acontece:

$ git add .gitignore
$ git commit -m "adicionando o .gitignore"
[master 100465c] adicionando o .gitignore
 1 file changed, 2 insertions(+)
 create mode 100644 .gitignore

E agora está pronto? Não!

Ignorando o ignorado

Aparentemente o Git foi instruído a ignorar dois arquivos mas parece que ele não entendeu direito:

$ echo >> pastel_de_carne_com_ovo.md
$ git status
On branch master
Changes not staged for commit:
...
    modified:   pastel_de_carne_com_ovo.md

no changes added to commit (use "git add" and/or "git commit -a")

Como? Algo errado na sintaxe do «.gitignore»? Acontece que uma vez que o arquivo foi adicionado ao repositório ele continua a ser monitorado, mesmo que depois tenha sido inseridos no «.gitignore».

Mas felizmente há solução razoavelmente simples para resolver o problema:

$ git rm -r --cached .
rm '.gitignore'
rm 'README.md'
rm 'pastel_de_banana_com_canela.md'
rm 'pastel_de_carne.md'
rm 'pastel_de_carne_com_ovo.md'
rm 'pastel_de_carne_moída.md'
rm 'pastel_de_chocolate.md'
rm 'pastel_de_frango_com_curry.md'
rm 'pastel_de_queijo.md'
rm 'sobremesas.md'
$ git add .
$ git commit -m "remoção dos arquivos monitorados"
[master cf81176] remoção dos arquivos monitorados
 3 files changed, 24 deletions(-)
 delete mode 100644 pastel_de_carne.md
 delete mode 100644 pastel_de_carne_com_ovo.md
 delete mode 100644 pastel_de_frango_com_curry.md

Com git rm¹ removem-se todos os arquivos dentro do repositório e com git add os adicionamos novamente, desta vez o Git respeitará o conteúdo do «.gitignore» e deixará os arquivos e curingas listados nele de fora do repositório.

Aliás, no processo de faxina ele removeu até mesmo o registro do arquivo «pastel_de_carne.md» que eu havia deixado quieto.

(¹) Um bom momento agora para dizer que git rm apaga o arquivo tanto no repositório quanto no disco e que para remover apenas o que está no repositório deve-se usar o parâmetro “- -cached”, portanto, tenha cuidado.

Fim desta parte

Agora é a vez de encerrar a máquina virtual com vagrant halt e lembrar que ninguém o arquivo «README.md» não foi modificado e que ainda faz referência ao arquivo «pastel_de_carne.md». Isto fica para a próxima parte quando finalmente o repositório será disponibilizado — aí a alteração poderá ser feita remotamente.

Anúncios

Um comentário sobre “Usando o Git – parte 3

  1. Pingback: Usando o Git, terceira parte - Linux em Ação XYZ

Deixe um comentário

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair / Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair / Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair / Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair / Alterar )

Conectando a %s