-
1. Primeiros Passos
- 1.1 Sobre Controle de Versão
- 1.2 Uma Breve História do Git
- 1.3 O que é Git?
- 1.4 A Linha de Comando
- 1.5 Instalando o Git
- 1.6 Configuração inicial do Git
- 1.7 Obtendo Ajuda
- 1.8 Resumo
-
2. Fundamentos do Git
-
3. Ramificação (Branching) no Git
-
4. Git no Servidor
- 4.1 Os Protocolos
- 4.2 Colocando o Git em um Servidor
- 4.3 Gerando a sua Chave Pública SSH
- 4.4 Configurando o Servidor
- 4.5 Git Daemon
- 4.6 Smart HTTP
- 4.7 GitWeb
- 4.8 GitLab
- 4.9 Opções de Hospedagem de Terceiros
- 4.10 Resumo
-
5. Git Distribuído
-
6. GitHub
-
7. Ferramentas do Git
- 7.1 Seleção de Revisão
- 7.2 Área de Stage Interativa
- 7.3 Fazendo Stash e Limpando
- 7.4 Assinando Seu Trabalho
- 7.5 Pesquisando (Searching)
- 7.6 Reescrevendo o Histórico
- 7.7 Reset Desmistificado
- 7.8 Merging Avançado
- 7.9 Rerere
- 7.10 Depurando com Git
- 7.11 Submódulos
- 7.12 Empacotando (Bundling)
- 7.13 Substituir (Replace)
- 7.14 Armazenamento de Credenciais
- 7.15 Resumo
-
8. Customizando o Git
- 8.1 Configuração do Git
- 8.2 Atributos do Git
- 8.3 Hooks do Git
- 8.4 Uma Política de Exemplo Imposta pelo Git
- 8.5 Resumo
-
9. Git e Outros Sistemas
- 9.1 Git como Cliente
- 9.2 Migrando para o Git
- 9.3 Resumo
-
10. Git Internals (Por Dentro do Git)
- 10.1 Encanamento e Porcelana (Plumbing and Porcelain)
- 10.2 Objetos do Git
- 10.3 Referências do Git
- 10.4 Arquivos de pacote (Packfiles)
- 10.5 Refspec
- 10.6 Protocolos de Transferência
- 10.7 Manutenção e Recuperação de Dados
- 10.8 Variáveis de Ambiente
- 10.9 Resumo
-
A1. Appendix A: O Git em Outros Ambientes
- A1.1 Interfaces Gráficas
- A1.2 Git no Visual Studio
- A1.3 Git no Visual Studio Code
- A1.4 Git no IntelliJ / PyCharm / WebStorm / PhpStorm / RubyMine
- A1.5 Git no Sublime Text
- A1.6 Git no Bash
- A1.7 Git no Zsh
- A1.8 Git no PowerShell
- A1.9 Resumo
-
A2. Appendix B: Incorporando o Git nos seus Aplicativos
- A2.1 Linha de Comando do Git
- A2.2 Libgit2
- A2.3 JGit
- A2.4 go-git
- A2.5 Dulwich
-
A3. Appendix C: Comandos do Git
- A3.1 Configuração e Ajustes
- A3.2 Obtendo e Criando Projetos
- A3.3 Snapshots Básicos
- A3.4 Branches e Merges
- A3.5 Compartilhando e Atualizando Projetos
- A3.6 Inspeção e Comparação
- A3.7 Depuração
- A3.8 Patches
- A3.9 E-mail
- A3.10 Sistemas Externos
- A3.11 Administração
- A3.12 Comandos de Encanamento
1.1 Primeiros Passos - Sobre Controle de Versão
Este capítulo é sobre como dar os primeiros passos com o Git. Começaremos explicando alguns fundamentos sobre ferramentas de controle de versão, em seguida, passaremos para como fazer o Git rodar em seu sistema e, por fim, como configurá-lo para começar a trabalhar. Ao final deste capítulo, você deverá entender por que o Git existe, por que você deve usá-lo e deve estar com tudo configurado para fazê-lo.
Sobre Controle de Versão
O que é “controle de versão”, e por que você deveria se importar? O controle de versão é um sistema que registra as mudanças em um arquivo ou conjunto de arquivos ao longo do tempo, para que você possa recuperar versões específicas mais tarde. Para os exemplos neste livro, você usará o código-fonte de software como os arquivos sendo controlados, embora na realidade você possa fazer isso com quase qualquer tipo de arquivo em um computador.
Se você é um designer gráfico ou web e deseja manter cada versão de uma imagem ou layout (o que você certamente iria querer), usar um Sistema de Controle de Versão (VCS) é uma decisão muito sábia. Ele permite que você reverta arquivos selecionados para um estado anterior, reverta o projeto inteiro para um estado anterior, compare as alterações ao longo do tempo, veja quem modificou por último algo que pode estar causando um problema, quem introduziu um problema e quando, e mais. Usar um VCS também geralmente significa que se você estragar as coisas ou perder arquivos, pode se recuperar facilmente. Além disso, você obtém tudo isso com muito pouco esforço adicional.
Sistemas de Controle de Versão Locais
O método de controle de versão preferido de muitas pessoas é copiar os arquivos para outro diretório (talvez um diretório com carimbo de data/hora, se elas forem espertas). Essa abordagem é muito comum porque é muito simples, mas também é incrivelmente sujeita a erros. É fácil esquecer em qual diretório você está e acidentalmente escrever no arquivo errado ou sobrescrever arquivos que você não pretendia.
Para lidar com esse problema, os programadores desenvolveram, há muito tempo, VCSs locais que tinham um banco de dados simples que mantinha todas as alterações nos arquivos sob controle de revisão.
Uma das ferramentas VCS mais populares foi um sistema chamado RCS, que ainda é distribuído com muitos computadores hoje. O RCS funciona mantendo conjuntos de patches (isto é, as diferenças entre arquivos) em um formato especial no disco; ele pode então recriar a aparência de qualquer arquivo em qualquer ponto no tempo, somando todos os patches.
Sistemas de Controle de Versão Centralizados
O próximo grande problema que as pessoas encontram é que precisam colaborar com desenvolvedores em outros sistemas. Para lidar com esse problema, os Sistemas de Controle de Versão Centralizados (CVCSs) foram desenvolvidos. Esses sistemas (como CVS, Subversion e Perforce) possuem um único servidor que contém todos os arquivos versionados, e vários clientes que fazem o checkout dos arquivos desse local central. Por muitos anos, este tem sido o padrão para controle de versão.
Essa configuração oferece muitas vantagens, especialmente sobre os VCSs locais. Por exemplo, todo mundo sabe, até certo ponto, o que todos os outros no projeto estão fazendo. Os administradores têm um controle refinado sobre quem pode fazer o quê, e é muito mais fácil administrar um CVCS do que lidar com bancos de dados locais em cada cliente.
No entanto, essa configuração também tem algumas desvantagens sérias. A mais óbvia é o ponto único de falha que o servidor centralizado representa. Se esse servidor ficar inativo por uma hora, durante essa hora ninguém poderá colaborar de forma alguma ou salvar alterações versionadas em nada no qual estejam trabalhando. Se o disco rígido onde o banco de dados central está for corrompido e não tiverem sido mantidos backups adequados, você perde absolutamente tudo — o histórico inteiro do projeto, exceto quaisquer snapshots únicos que as pessoas tenham em suas máquinas locais. Os VCSs locais sofrem do mesmo problema — sempre que você tem o histórico inteiro do projeto em um único lugar, corre o risco de perder tudo.
Sistemas de Controle de Versão Distribuídos
É aqui que os Sistemas de Controle de Versão Distribuídos (DVCSs) entram em cena. Em um DVCS (como Git, Mercurial ou Darcs), os clientes não fazem apenas o checkout do snapshot mais recente dos arquivos; em vez disso, eles espelham totalmente o repositório, incluindo todo o seu histórico. Assim, se qualquer servidor morrer, e esses sistemas estivessem colaborando através desse servidor, qualquer um dos repositórios dos clientes pode ser copiado de volta para o servidor para restaurá-lo. Cada clone é realmente um backup completo de todos os dados.
Além disso, muitos desses sistemas lidam muito bem com a existência de vários repositórios remotos com os quais podem trabalhar, de modo que você pode colaborar com diferentes grupos de pessoas de diferentes maneiras, simultaneamente, dentro do mesmo projeto. Isso permite que você configure vários tipos de fluxos de trabalho que não são possíveis em sistemas centralizados, como modelos hierárquicos.