AdybFadel.com desenvolvimento de software, tecnologia e inovação

Gerenciamento de Código com Git no Ubuntu – Básico

Nível técnico : Iniciante
Versões Testadas : Git 1.7.1 e Ubuntu 10.10
Âncoras : config | init | clone | add | status | diff | reset HEAD | rm | commit

Gerenciamento de Código-fonte

Qualquer que seja o tamanho do projeto de software ou a quantidade de desenvolvedores, o gerenciamento do código fonte é fundamental para que não haja perda do que já foi feito e testado. Se a cada tarefa, ou grupo de tarefas, concluída for feita uma cópia do projeto em um repositório, isso garante que futuras alterações possam ser desfeitas em caso de quebra no funcionamento do software. Outra vantagem é que um segundo programador que tenha acesso ao repositório, pode baixar a última versão testada e acrescentar ou aprimorar partes do código e enviá-lo novamente como um novo release, ou como um patch para que seja incorporado ao código principal, distribuindo o trabalhos de desenvolvimento a um número maior de pessoas.

Uma maneira mais eficiente e econômica (espaço em disco) de gerenciar código é, ao invés de fazer uma cópia de todo os arquivos, guardar apenas uma 'fotografia' (snapshot) do projeto a cada release, contendo informações dos estados de cada arquivo. Estes snapshots poderão ser usado para saber quais arquivos foram criados ou modificados no projeto.

Git

O Git é um dos mais utilizados sistemas de gerenciamento de código, principalmente em projetos open source. Ele utiliza o método de snapshots, o que o torna rápido e eficiente, provê o rastreamento de todo o histórico de commits do projeto e não depende de um servidor central para guardas o repositório, como em outros sistemas similares.

Outra grande vantagem do uso do Git é a possibilidade de você poder usar o GitHub, um serviço de repositório de código na web que permite o desenvolvimento colaborativo remoto.

Alguns projetos que utilizam o Git: Kernel do Linux, Gnome, Ruby on Rails, Android, Debian, entre outros.

Para saber mais a respeito do Git, acesse gitref.org (inglês).

1. Instalação e Configuração

1.1. Instalando com "Gerenciador de pacotes Synaptic"

a) No menu 'Sistemas > Administração', abra o 'Gerenciador de pacotes Synaptic';
b) Faça uma pesquisa rápida com a palavra 'git';
c) Clique com o botão direito e marque para instalação os pacotes: git, git-gui e git-doc.

1.2. Instalando com "apt-get" no terminal

Abra um terminal e execute o comando:

$ sudo apt-get install git git-gui git-doc

sudo : executa o comando seguinte como administrador (root).
apt-get install : instala novos pacotes de software.
git : é o próprio Git e alguns scripts da interface com ele.
git-gui (opcional) : fornece a interface gráfica do git.
git-doc (opcional) : como o próprio nome diz, é a documentação do git.

Agora execute o comando a seguir para verificar a instalação:

$ git --version
git version x.x.x


OBS: Apesar de opcional é recomendado a instalação dos pacotes git-gui e git-doc. Existem pacotes para quem estiver migrando de outros SCV's como: git-snv (Subversion), git-cvs (CVS), etc. Para maiores informações, visite o Wiki do Git (em inglês).

1.3. Configurações Globais

Após a instalação é recomendado informar ao Git seu nome e email, para serem utilizados na identificação de cada commit.

No terminal, execute:

$ git config --global user.name "Seu Nome"
$ git config --global user.email "seu@email.com"


2. Utilização

Existem interfaces gráficas para uso do Git, mas o mais comum é usar o bom e velho terminal (ou linha de comando).

2.1. Inicializando um Repositório

O Git utiliza o próprio diretório do projeto com repositório.

Para este exemplo, vamos criar um novo diretório e criar um arquivo em branco destro dele:

$ mkdir inigit
$ cd inigit
$ touch teste.txt


Agora, para inicializar o repositório deste projeto, execute:

$ git init
Initialized empty Git repository in /caminho/projeto/.git

Se você listar o diretório, verá o subdiretório '.git' criado:

$ ls -a
.  ..  teste.txt  .git

Pronto, o repositório esta inicializado e pronto para o primeiro commit.

2.2. Copiando um Repositório

Se você for colaborar com o desenvolvimento de algum projeto, ou mesmo copiá-lo para usá-lo como ponto de partida, você pode usar o comando 'git clone [url]', aonde '[url]' é o caminho completo para o projeto.

$ git clone git://github.com/adybfadel/hellogit.git
Initialized empty Git repository in /../hellogit/.git/
remote: Counting objects: 4, done.
remote: Compressing objects: 100% (3/3), done.
Receiving objects: 100% (4/4), done.
remote: Total 4 (delta 0), reused 0 (delta 0)

Mude para o diretório do projeto e veja ficou.

$ cd hellogit
$ ls -a
.  ..  .git hello.txt README.txt

Por padrão o Git cria o novo diretório com o nome do projeto informado no final da URL, depois da última barra.

Neste exemplo foi utilizado o GitHub, que acrescenta '.git' depois do nome do repositório, por isso foi criado o diretório com o nome 'hellogit' apenas.

Se estiver clonando um projeto local (na própria máquina ou via ssh), a URL é do diretório do projeto (Ex.: /home/adyb/hellogit ou ../adyb/hellogit).

Para forçar a criação do diretório com outro nome, basta informá-lo após a URL (Ex.: /hom/adyb/hellogit helloworld).

2.2. Salvando Modificações no Projeto

O Git utiliza um índice que serve como uma espécie de "pulmão" para as alterações no projeto antes do commit ser feito. Isso permite as modificações sejam marcadas e comparadas no índice antes de serem gravadas no repositório, possibilitando que você revise-as antes de efetivamente salvá-las.

Mude novamente para o projeto 'inigit' e verifique seu estado para saber quais modificações ainda não foram marcadas.

$ cd inigit
$ git status -s
?? teste.txt

Como neste projeto o repositório ainda está vazio, o arquivo 'teste.txt' está com status '??' (não rastreado). Para que ele seja gravado no repositório no próximocommit (nesse caso, no primeiro), você precisa marcá-lo com:


$ git add teste.txt

Podemos ver o comando 'add' como o botão da máquina fotográfica, ao acioná-lo o Git cria um snapshot do estado do arquivo para o próximo commit.

OBS: Você pode usar 'add .' para marcar todos os arquivos, em toda a árvore de diretórios do seu projeto de uma só vez.

Verificando novamente, agora 'teste.txt' está com status 'A' (adicionado/added) à esquerda, indicando que ele será gravado no próximo commit.

$ cd inigit
$ git status -s
A teste.txt

Adicione algum texto ao  conteúdo de 'teste.txt' (Ex.: "Utilizando Git") com algum editor de textos e você verá que ele recebe o flag 'M' (modificado/modified) do lado direito, indicando que ele foi modificado mas ainda não foi marcado para o próximo commit.

$ gedit teste.txt
$ git status -s
AM teste.txt

OBS: Somente os arquivos cuja flag da esquerda está ativa, terão seus snapshots gravados no repositório no próximo commit.

Para saber quais modificações foram feitas em cada arquivo do projeto, antes do commit, você pode utilizar o comando 'diff' do Git:

$ git diff teste.txt
diff --git a/teste.txt b/teste.txt
index e69de29..3d6f088 100644
--- a/teste.txt
+++ b/teste.txt
@@ -0,0 +1 @@
+Utilizando Git


Ele mostra quais linhas foram alteradas no arquivo indicado. Se não for passado nenhum nome de arquivo, serão mostrados todos os arquivos rastreados que foram modificados desde o último commit.

Por fim, para efetivamente gravar as modificações no repositório, execute o comando 'commit'. Contudo, você precisa primeiro tirar outra "fotografia" dos arquivos modificados.


$ git add teste.txt
$ git commit -m 'Primeiro commit'
[master e55ce3a] Primeiro commit
1 files changed, 1 insertions(+), 1 deletions(-)


Ao salvar o snapshot do projeto, o Git grava a mensagem de commit, fornecida após '-m', no arquivo '.git/COMMIT_EDITMGS'. Portanto, é recomendado que esta mensagem seja bem explicativa das modificações feitas no código. Caso não seja fornecido parâmetro '-m' com a mensagem, será aberto um editor de texto para que esta seja escrita.

Outro parâmetro muito utilizado com o comando 'commit' é o '-a' (Ex.: $ git commit -am 'Primeiro commit') que salva automaticamente todos os arquivo rastreados, mesmo os que não foram marcados com 'add arquivo'.

Caso algum arquivo seja marcado por engano*, você pode remover a flag com 'reset HEAD arquivo'

$ gedit teste.txt
$ git status -s
_M teste.txt
$ git add teste.txt
$ git status -s
M_ teste.txt
$ git reset HEAD teste.txt
Unstaged changes after reset:
M       teste.txt
$ git status -s
_M teste.txt

Repare que, após a modificação no arquivo seu status é 'M' à direita, indicando que ainda não foi "fotografado". Quando o adicionado ao índice seu status passa a ser 'M' à esquerda, marcado para o próximo commit. Quando e feito o 'reset HEAD' o status para 'M' à direita, isto é, ele não será salvo no próximo commit.

Para remover as flags de um arquivo, ou seja, torná-lo "não rastreado" pelo Git, você precisa utilizar o comando 'gir rm --cached arquivo'.

$ git rm --cached teste.txt
rm 'teste.txt'
$ git status -s
D_ teste.txt
?? teste.txt


Repare que o arquivos ficou sem marcação ('??'), ou seja, está sendo rastreado pelo Git. Se você usar o parâmetro '-f' no lugar de '--chached' o arquivo será removido do diretório do projeto (mesmo que '$ rm arquivi', no shell do Linux), então CUIDADO!

Conclusão

Neste post foram passadas alguns conceitos de como funciona o Git, um excelente sistema de gerenciamento de código, e apresentadas instruções básicas de sua utilização.

Está longe de ser um guia completo desta poderosa ferramenta, até mesmo porque não foi a minha intenção ao escrevê-lo, para maiores informações a respeito do Git, acesse:

http://git-scm.com - Site oficial do Git (inglês)
http://progit.org/book - eBook do Git (inglês)
http://gitref.org - Guia de referência do git (inglês)

Para uma lista dos commando do Git mais communs, digite na linha de comando:

$ git --help

ou, para detalhes de algum comando específico:

$ git COMMAND --help

Em breve estarei colocando neste blog um post sobre Git avançado e GitHub, até lá!

FIM