A base aqui é preparar um projeto Delphi Git e publicar no GitHub. Neste exemplo usei uma demonstração do uso de um TWebBrowser para mostrar um gráfico do Google Chart Api. O repo foi originário de uma pergunta que rolou na lista do DUG-RS e aproveitei para brincar um pouco.

Antes de qualquer coisa… instale o Git para a plataforma Windows. 🙂

Eu gosto de usar o Git pela linha de comando mas o GitHub fez um cliente para windows. Fica a sua escolha.

Acostumei a usar a linha de comando e posso garantir a você que é bem tranquilo de trabalhar. Te dá controle e uma vontade constante de manter o repositório atualizado. A integração de código com a base de código no repositório agradece!

Sobre outras opções de instalação, se você é usuário do Tortoise SVN pode ter interesse em avaliar o Tortoise GIT.

Bom, depois de instalar vamos via “Git Bash” até a pasta onde está o seu código fonte.
Para saber a pasta atual, use o comando “pwd”.

Estando na pasta, vamos inicializar um repositório Git através do comando:

$ git init
Initialized empty Git repository in c:/Users/dwildt/Code/google-graph/.git/

A partir do comando de status, podemos ver todos os arquivos que devem ser enviados para o repositório:

$ git status
# On branch master
#
# Initial commit
#
# Untracked files:
# (use “git add <file>…” to include in what will be committed)
#
# GoogleGraph.cfg
# GoogleGraph.dof
# GoogleGraph.dpr
# GoogleGraph.res
# GoogleGraph.~dpr
# dcu/
# exe/
# src/
nothing added to commit but untracked files present (use “git add” to track)

Note que ali na listagem aparecem arquivos .~dpr e aparecem pastas exe e dcu. Não queremos estas pastas no nosso controle de versão. Então vamos criar um arquivo “.gitignore“. Para fazer a criação deste arquivo, vamos fazer um touch e depois editar o arquivo usando o VIM. Você também pode fazer a edição deste arquivo pelo próprio Delphi, mas enfim, aproveite para brincar um pouco com o VIM.

$ touch .gitignore
$ vim .gitignore

Ao entrar no VIM, entramos em modo de inserção pressionando “I”. E vamos digitar o seguinte:

*.~*
*.dcu
*.exe
exe
dcu

Para sair do VIM, vamos fazer: <ESC> + :wq + <ENTER>
Para conferir o conteúdo do arquivo podemos usar o comanto “cat”:

$ cat .gitignore

Então em resumo, coloquei que arquivos com extensão dcu, exe e qualquer arquivo que a extensão comece com “~” deve ser deixado de lado. Ainda, que as pastas exe e dcu não devem ser consideradas. Ao fazer um novo git status os arquivos que estão no .gitignore já não aparecem mais.

Sobre a estrtutura de projeto, eu normalmente configuro meus projetos com a estrutura de pastas:

• src – fontes
• dcu – units compiladas
• exe – binários
• Tenho outras pastas que crio normalmente (exemplo docs), mas para o foco do post está ok.

Agora vamos fazer um commit dos arquivos. Você pode estar se perguntando onde configuramos o repositório. Ainda não configuramos. E aí você me pergunta como assim não configuramos? Como você vai fazer um commit sem ter um repositório definido. Bom, vamos ver na prática:

$ git add .

O comando acima adiciona todos arquivos que não estão “controlados” no commit a ser feito. Agora vamos fazer o commit.

$ git commit -am “primeiro commit do demo com google graph e twebbrowser”
[master (root-commit) f7ca3f2] primeiro commit do demo com google graph e twebbrowser
7 files changed, 474 insertions(+), 0 deletions(-)
create mode 100644 .gitignore
create mode 100644 GoogleGraph.cfg
create mode 100644 GoogleGraph.dof
create mode 100644 GoogleGraph.dpr
create mode 100644 GoogleGraph.res
create mode 100644 src/UFormGoogleGraph.dfm
create mode 100644 src/UFormGoogleGraph.pas

Com este comando, ao fazer um git status, temos:

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

E aqui mora o principal problema de quem começa a trabalhar com o git, de confundir o commit que realizamos aqui com uma operação de checkin em um SubVersion por exemplo. Ao fazer um commit, apenas estamos “indicando que aquela unidade de trabalho foi finalizada”. Durante um dia de trabalho, devemos fazer diversos commits, e pequenos commits.

Isto está muito ligado com a prática de Continuous Integration. Devemos garantir que o nosso código está no controle de versão e sendo compilado e validado. Isto é assunto mais específico para outro post. O objetivo aqui é aproveitar este demo que fiz, para poder mostrar como podemos usar o Git com Delphi.

Ok, mas e aí, e o tal repositório?

Vou usar o GitHub, e vou criar um repositório. Lá fui eu e criei na minha conta o repositório abaixo:
https://github.com/dwildt/google-pie-graph-with-delphi-twebbrowser

Aí para poder enviar e sincronizar os arquivos, vou adicionar um “remote“, que é a forma que tenho para conectar meu fonte local com uma fonte remota. Voltamos para a linha de comando.

$ git remote add origin git@github.com:dwildt/google-pie-graph-with-delphi-tweb
browser.git

E feito isto, agora vou sincronizar meus dados com o repositório.

$ git push origin master
Counting objects: 10, done.
Compressing objects: 100% (9/9), done.
Writing objects: 100% (10/10), 5.07 KiB, done.
Total 10 (delta 0), reused 0 (delta 0)
To git@github.com:dwildt/google-pie-graph-with-delphi-twebbrowser.git
* [new branch] master -> master

Fazemos isto através de um push. Origin é o nome que dei para o remote no passo acima. Master é o nome do branch. O master é o branch principal.

E pronto, seu projeto está agora no Github. O ponto é que agora o processo vai ser:

• git status para ver o que modificou
• git add e git commit para registrar as mudanças.
• git push para enviar as mudanças para o seu repositório.

Você pode ter mais de um remote configurado, isto é tranquilo. Você pode ter por exemplo, o seu remote para controle de versão puro e pode ter um outro que quando recebe o código fonte, realiza um build e instala a versão em um determinado ambiente.

Para conhecer mais sobre GIT, deixo referências:

• Introdução do próprio GitHub.
• Git SCM Book. Versão também em português.
• Livro do TAQ.