pt_br/basic.txt

   1 == Truques básicos ==
   2
   3 Ao invés de se aprofundar no mar de comandos do Git, use estes exemplos elementares para dar os primeiros passos. Apesar de sua simplicidade, cada um deles são muito úteis. Na verdade, no meu primeiro mês com o Git, nunca precisei ir além das informações deste capítulo.
   4
   5 === Salvando estados ===
   6
   7 Pensando em tentar algo mais arriscado? Antes de fazê-lo, tire uma “fotografia” de todos os arquivos do diretório atual com:
   8
   9  $ git init
  10  $ git add .
  11  $ git commit -m "My first backup"
  12
  13 Assim se algo der errado, você só precisará executar:
  14
  15  $ git reset --hard
  16
  17 Para salvar o estado novamente, faça:
  18
  19  $ git commit -a -m "Another backup"
  20
  21 === Adicionar, Remover, Renomear ===
  22
  23 Os comandos acima só irão verificar alterações nos arquivos que estavam presentes quando você executou seu primeiro *git add*. Se você adicionar novos arquivos ou diretórios terá que informar ao Git, com:
  24
  25  $ git add readme.txt Documentation
  26
  27 Do mesmo modo, se você quiser que o Git não verifique certos arquivos, faça:
  28
  29  $ git rm kludge.h obsolete.c
  30  $ git rm -r incriminating/evidence/
  31
  32 O Git irá apagar estes arquivos, se você ainda não apagou.
  33
  34 Renomear um arquivo é o mesmo que remover o nome antigo e adicionar um novo nome. Há também o atalho *git mv* que tem a mesma sintaxe do comando *mv*. Por exemplo:
  35
  36  $ git mv bug.c feature.c
  37
  38 === Desfazer/Refazer avançado ===
  39
  40 Às vezes, você só quer voltar e esquecer todas as mudanças realizadas a partir de um certo ponto, pois estão todos erradas. Então:
  41
  42  $ git log
  43
  44 mostrará uma lista dos últimos commit e seus hash SHA1:
  45
  46 ----------------------------------
  47 commit 766f9881690d240ba334153047649b8b8f11c664
  48 Author: Bob <bob@example.com>
  49 Date:   Tue Mar 14 01:59:26 2000 -0800
  50
  51     Replace printf() with write().
  52
  53 commit 82f5ea346a2e651544956a8653c0f58dc151275c
  54 Author: Alice <alice@example.com>
  55 Date:   Thu Jan 1 00:00:00 1970 +0000
  56
  57     Initial commit.
  58 ----------------------------------
  59
  60 Os primeiros caracteres do hash são suficientes para especificar o commit; alternativamente, copie e cole o hash completo. Digite:
  61
  62  $ git reset --hard 766f
  63
  64 para restaurar ao estado de um dado commit e apagar permanentemente os registros de todos os novos commit a partir deste ponto.
  65
  66 Outras vezes você quer voltar, brevemente, para um estado. Neste caso, digite:
  67
  68  $ git checkout 82f5
  69
  70 Isto levará você de volta no tempo, preservando os novos commit. Entretanto, como nas viagens no tempo dos filmes de ficção, se você editar e fizer um commit, você estará numa realidade alternativa, pois suas ações são diferentes das realizadas da primeira vez.
  71
  72 Esta realidade alternativa é chamada de branch, nós falaremos mais sobre isso depois. Por ora, apenas lembre-se que:
  73
  74  $ git checkout master
  75
  76 lhe levará de volta para o presente. Assim faça o Git parar de reclamar, sempre faça um commit ou reset em suas alterações antes de executar um checkout.
  77
  78 Voltemos para a analogia dos jogos de computador :
  79
  80 - *`git reset --hard`*: carrega um salvamento antigo e apaga todos jogos salvos  mais novos do que este que foi carregado.
  81
  82 - *`git checkout`*: carrega um salvamento antigo, mas se jogar a partir dele, os próximos salvamento realizados se desvincularão dos salvamentos já realizados após o que foi carregado. Qualquer jogo salvo que você fizer será colocado em um branch separado representado uma realidade alternativa em que entrou. Lidaremos com isso mais adiante. <<branch,We deal with this later>>.
  83
  84 Você pode escolher restaurar apenas alguns arquivos ou diretórios acrescentando-os ao final do comando:
  85
  86  $ git checkout 82f5 some.file another.file
  87
  88 Tome cuidado, pois esta forma de *checkout* pode sobrescrever arquivos sem avisar. Para prevenir acidentes, faça um commit antes de qualquer comando checkout, especialmente quando esta aprendendo a utilizar o Git. De modo geral, sempre que se sentir inseguro sobre alguma operação, seja um comando Git ou não, execute primeiro o comando *git commit -a*.
  89
  90 Não gosta de copiar e colar hash? Então use:
  91
  92  $ git checkout :/"My first b"
  93
  94 para ir ao commit que começa a frase informada. Você também pode solicitar pelo estado salvo ha 5 commit atrás:
  95
  96  $ git checkout master~5
  97
  98 === Revertendo ===
  99
 100 Como num tribunal, eventos podem ser retirados dos registros. Da mesma maneira, você pode especificar qual commit desfazer.
 101
 102  $ git commit -a
 103  $ git revert 1b6d
 104
 105 irá desfazer apenas o commit do hash informado. A regressão é gravada como um novo commit, e que pode ser confirmada executando o comando *git log*.
 106
 107 === Geração do Changelog ===
 108
 109 Alguns projetos precisam de um http://en.wikipedia.org/wiki/Changelog[changelog].
 110 Podemos gerar um changelog com o comando:
 111
 112  $ git log > ChangeLog
 113
 114 === Download de arquivos ===
 115
 116 Para obter uma cópia de um projeto gerenciado com GIT digite:
 117
 118  $ git clone git://server/path/to/files
 119
 120 Por exemplo, para obter todos os arquivos usados para criar este site:
 121
 122  $ git clone git://git.or.cz/gitmagic.git
 123
 124 Mais adiante, teremos muito o que dizer sobre o comando *clone*.
 125
 126 === A Última Versão ===
 127
 128 Se você já obteve a cópia de um projeto usando *git clone*, pode agora atualizar para a última versão com:
 129
 130  $ git pull
 131
 132 === Publicação instantânea ===
 133
 134 Suponha que você tenha escrito um script e gostaria de compartilhá-lo. Você poderia simplesmente dizer para pegarem do seu computador, mas se o fizerem enquanto você está melhorando o script ou experimentando algumas mudanças, eles podem ter problemas. Obviamente, é por isso que existem ciclos de liberação. Desenvolvedores podem trabalhar num projeto com frequência, mas só disponibilizam o código quando sentem que o mesmo está apresentável.
 135
 136 Para fazer isso com Git, no diretório onde está seu script, execute:
 137
 138  $ git init
 139  $ git add .
 140  $ git commit -m "First release"
 141
 142 Então avise aos outros para executarem:
 143
 144  $ git clone your.computer:/path/to/script
 145
 146 para obter seu script. Assume-se que eles têm acesso ssh. Se não, execute *git daemon* e avise-os para executar:
 147
 148  $ git clone git://your.computer/path/to/script
 149
 150 A partir de agora, toda vez que seu script estiver pronto para liberar, execute:
 151
 152  $ git commit -a -m "Next release"
 153
 154 e seu usuários podem atualizar suas versões, indo para o diretório que contém seu script, e executando:
 155
 156  $ git pull
 157
 158 Seu usuários nunca ficarão com uma versão do seu script que você não queira. Obviamente este truque serve para tudo, não apenas script.
 159
 160 === O que eu fiz? ===
 161
 162 Saiba quais as mudanças que você fez desde o último commit com:
 163
 164  $ git diff
 165
 166 Ou desde ontem:
 167
 168  $ git diff "@{yesterday}"
 169
 170 Ou entre uma versão particular e duas versões atrás:
 171
 172  $ git diff 1b6d "master~2"
 173
 174 Em cada um dos exemplos, a saída será um patch que pode ser aplicado com o *git apply*. Tente também:
 175
 176  $ git whatchanged --since="2 weeks ago"
 177
 178 Às vezes navego pelo histórico com o http://sourceforge.net/projects/qgit[qgit], em razão de sua interface mais fotogênica, ou com o http://jonas.nitro.dk/tig/[tig], uma interface em modo texto ótima para conexões lentas. Alternativamente, instale um servidor web, e execute git instaweb e use um navegador.
 179
 180 === Exercícios ===
 181
 182 Seja A, B, C D quatro commits sucessivos onde B é idêntico a A exceto por alguns arquivos que foram removidos. Queremos adicionar novamente os arquivos em D. Como podemos fazer isso?
 183
 184 Existem no minimo 3 soluções. Assumindo que estamos em D.
 185
 186   1. A diferença entre A e B são or arquivos removidos. Podemos criar um patch representando esta diferença e aplicá-la:
 187
 188    $ git diff B A | git apply
 189
 190   2. Como salvamos os arquivos em A, podemos recuperá-los:
 191
 192    $ git checkout A foo.c bar.h
 193
 194   3. Podemos visualizar as mudanças de A para B que queremos desfazer:
 195
 196    $ git revert B
 197
 198 Qual a opção é melhor? A que você preferir, É fácil fazer o que você quer com o git, e na maioria das vezes existe mais de uma forma de fazê-lo.