Git - Guia Prático

Oct 20, 2014 17:26 · 1396 words · 7 minutes read

A princípio montei este guia para a Bis2Bis, onde estamos começando a usar git, porém nem todos os integrantes da equipe são programadores ou entendem sobre controle de versão.

O objetivo aqui é facilitar um entendimento rápido de como operar um repositório git, permitindo um trabalho em equipe facilitado. Iremos da criação ou clonagem de repositórios até a interação básica com outros.

O foco será na operação do repositório via o executável oficial do git, ou seja, pela linha de comando. Porém, se os conceitos forem absorvidos corretamente, é possível usar o git com diversas outras ferramentas, inclusives muitas delas gráficas.

Apesar do nosso foco prático, vale reforçar que entender a teoria por trás do funcionamento do git facilita muito seu uso.

O que é o git?

O git é um sistema de controle de versões, que grava mudanças a arquivos ou conjuntos de arquivos ao longo do tempo, para que você possa alternar ou checar outras versões mais tarde. Apesar de ser muito bom para se trabalhar em equipe, também é muito útil para a organização de projetos solo.

Algumas coisas que você pode fazer com git:

  • Visualizar tudo que foi feito anteriormente;
  • Trazer de volta versões anteriores de arquivos ou projetos inteiros;
  • Comparar modificações entre versões;
  • Facilitar combinação de arquivos (2 ou mais pessoas trabalhando na mesma coisa);
  • Criar e manipular diversas versões do mesmo projeto;

Instalação

O Git possui instaladores gráficos para Windows e Mac. Basta baixá-los e realizar uma instalação padrão.

Ao final da instalação, devemos ter uma linha de comando Git funcional (Git Bash, no Windows).

Configuração de usuário

Após a instalação, é necessário realizar a configuração da aplicação. Os comandos a seguir configuram as informações que serão gravadas no histórico, e só precisam ser executados uma vez:

$ git config --global user.name "Nome Sobrenome"
$ git config --global user.email "email@endereco.com"

Usando o repositório

Por ser um repositório descentralizado, cada computador de trabalho possui as mesmas funcionalidade de um servidor git.

Durante o fluxo de trabalho iremos manipular apenas o repositório local, adicionando, modificando ou removendo arquivos.

Após um ciclo de trabalho, é necessário sincronizar seu repositório com o repositório compartilhado, e apenas após isto enviar suas mudanças. Desta maneira, cada um fica responsabilizado por juntar suas mudanças com as do resto da equipe.

Comandos de Transporte de Dados

Preparando um projeto

Projetos existentes:

Caso um repositório remoto exista, você deve cloná-lo da seguinte maneira:

$ git clone usuario@servidor:pasta/com/projeto.git

Este comando irá criar uma pasta de nome ‘projeto’ no diretório atual, já atualizado com as últimas modificações.

Projetos novos:

Caso o repositório remoto não exista (ou esteja vazio), você deve criá-lo utilizando o git init dentro da pasta do projeto.

$ pwd #Verificando se estamos dentro da pasta do projeto
/pasta/raiz/projeto #Retorno do comando acima, verificamos que está certo
$ git init

Ignorando arquivos

Se necessário, é possível pedir ao git que não versione determinados arquivos. Para isto, basta criar um arquivo .gitignore na pasta raiz do projeto.

Cada linha escrita no .gitignore representa um caminho ou um arquivo que deve ser ignorado pelo sistema de versionamento.

.idea/
.phpstorm.meta.php
/app/etc/local.xml
/var/

Neste exemplo, o arquivo app/etc/local.xml diretamente e todos os arquivos dentro da pasta var, indiretamente.

Devemos sempre tentar ignorar os arquivos e pastas que a equipe não irá modificar, ou que serão úteis apenas individualmente e podem atrapalhar o resto da equipe.

Fluxo de trabalho

Neste ponto você já deve estar pronto para começar a versionar o seu projeto.

Trabalhando com Git, normalmente temos o seguinte fluxo:

  1. git add - adicionando suas modificações;
  2. git commit - Confirmando e salvando suas modificações;
  3. git pull - Atualizando seu projeto com as modificações da equipe;
  4. git push - Atualizando o repositório da equipe com suas modificações;

Adicionando arquivos

Podemos adicionar modificações individualmente no versionamento:

$ git add helloworld.txt

Ou para adicionar tudo de uma só vez:

$ git add -A #ou git add --all

Este comando também possui um modo interativo, que vai perguntando o que você deseja fazer:

$ git add -i

Checando Status

Para saber em qual estado se encontra o seu diretório de trabalho, pode-se usar o comando ‘git status’. Este comando informa se o repositório local está limpo ou se existem mudanças locais desde o último commit.

Para checar o status do repositório local:

On branch master
Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)

    new file:   helloworld.txt

Neste exemplo o comando retorna informando o arquivo ‘helloworld.txt’ será adicionado no próximo commit.

Realizando Commits

Para realizar o commit:

$ git commit -m "Comentário do commit"

Você deve ver um output semelhante a:

[master (root-commit) 9416416] Comentário do commit
1 files changed, 1 insertions(+), 0 deletions(-)
 create mode 100644 helloworld.txt

Neste exemplo o comando retorna informando que o diretório de trabalho está igual ao repositório local, portanto se encontra limpo. Podemos realizar operações com outros repositórios.

Checando status novamente

É sempre interessante checar como está seu repositório antes e depois das operações:

$ git status
On branch master
nothing to commit (working directory clean)

Neste exemplo o comando retorna informando que o diretório de trabalho está igual ao repositório local, portanto se encontra limpo (clean). Este estado é necessário para que se realize interações com outros repositórios.

Visualizando Histórico

Para visualizar seu repositório local, existe uma ferramenta gráfica muito útil chamada gitk. Este comando traz uma ferramenta padrão do git e pode ser utilizado a qualquer momento. Ele abre uma janela contendo cada commit feito no projeto, mostrando o que foi feito a cada passo.

Interagindo com outros repositórios

Tudo o que fizemos até agora ocorreu na sua máquina, de forma local. Ainda não usamos a internet e nem interagimos com outros colegas de equipe ainda. O comando git commit apenas armazena informações no repositório local.

Após um ou mais commits, você tem a opção de enviar suas mudanças para algum servidor remoto compartilhado.

As explicações feitas aqui se referem a interações feitas diretamente entre os repositórios, sem intermediários. No caso de aplicações como Github ou Bitbucket existem os fluxos de pull request, que não serão cobertos aqui, pois variam de aplicação para aplicação.

Projetos existentes:

No caso de um projeto clonado, você já terá um repositório chamado origin na sua lista de repositórios conhecidos:

$ git remote #verificando quais repositórios remotos existem
origin

Tudo certo, neste caso você está pronto para interagir com o origin.

Projetos novos:

Para projetos recem criados, é necessário se adicionar um repositório remoto:

$ git remote #verificando quais repositórios existem
$ git remote add origin git@endereco.com:projetos/projeto.git
$ git remote #tentando novamente
origin

Comandos de interação

É interessante ter alguns conhecimentos básicos sobre branches antes de utilizar estes comandos, mas para que se possa começar a interagir rapidamente, seguem alguns exemplos no proximo slide.

Os próximos comandos utilizam a branch ‘master’ para exemplificar suas funcionalidades, porém, nem sempre você ira querer interagir com a master.

Pulling

Antes de se enviar mudanças a um repositório remoto, deve-se pegar as mudanças ocorridas desde sua última interação.

$ git pull origin master #verifica e combina as modificações do origin

É interessante apontar que git pull é um “comando de atalho”. Ele tem o mesmo efeito que outros dois comandos git:

$ git fetch origin master #verifica e baixa modificações existentes no origin
$ git merge origin/master master #combina as modificações

O fetch coleta as últimas mudanças do repositório remoto, e o merge realiza a junção das mudanças coletadas com as mudanças locais.

Pushing

Para enviar modificações a um servidor remoto, é utilizado o comando push:

$ git push origin master

Este comando só será concluído corretamente caso seu repositório esteja sincronizado com as últimas mudanças do repositório remoto.

Caso contrário, irá retornar uma mensagem de erro indicando que seu push foi rejeitado, e que é necessário executar um pull.

Revisão de comandos

Repassando rapidamente os comandos que vimos:

Criação:

$ git clone usuario@endereco:projetos/projeto.git #clonar repositório
$ git init #criar repositório local

Visualizando o que ocorre:

$ git status #mostra arquivos modificados
$ git diff HEAD #mostra as diferenças desde o último commit
$ gitk #abre programa padrão para visualização histórico

Preparando e realizando commits:

$ git add -A #adicionar todas as mudanças para o próximo commit
$ git add -i #menu interativo para adicionar mudanças
$ git commit -m 'mensagem' #salva todas as alterações adicionadas

Compartilhando suas mudanças:

$ git pull repositorio branch #baixa e merge mudanças automaticamente
$ git push repositorio branch #sobe suas mudanças a um servidor remoto