Git o que que é isso?

Prefácio:

Vamos entender como funciona este controlador de versão, pra que serve e por que ele é um pré-requisito para todas as vagas de programação.

Este artigo é totalmente conceitual, se você conseguir entender estes conceitos, será muito mais fácil de trabalhar com o GIT.

Este artigo não tem pré-requisitos

1 — Para começar iremos definir o que é um controlador de versão.

O controle de versão é qualquer ferramenta ou atividade que garante o histórico de criação e alteração de um arquivo.

E como isso pode nos ser útil?

O trabalho de um programador é basicamente criar e editar arquivos.

Imagine você em um time onde tem 5 pessoas trabalhando em um e-commerce alterando e criando arquivos, adicionando funcionalidades e ajustando bugs.

Falta um dia para o deploy (subir os arquivos no ambiente de produção), todos os programadores já terminaram os ajustes e estão fazendo os merges (juntando todas as alterações que foram feitas utilizando git).

Depois de terminado todos os merges, eles irão gerar uma release (vão gerar um número de versão para aquele conjunto de ajustes funcionalidades). No fim de todo este trabalho, eles irão gerar a versão 1.2 do e-commerce.

O próximo passo é rodar os testes unitários e caso seja executado com sucesso podemos fechar esse release e gerar a TAG (versão definitiva do sistema), jogar nosso pacote no servidor, e pronto!

Agora vamos supor que alguém esqueceu de fazer o teste unitário da nova funcionalidade do carrinho de compras. A nossa versão 1.2 foi para produção com um bug.

Após 5 minutos do deploy recebemos nossa primeira reclamação que não estão conseguindo finalizar uma compra no nosso site.

Com o git, facilmente pegamos a TAG anterior que estava em produção 1.1 e colocamos de volta no servidor. Assim os desenvolvedores terão tempo para encontrar e ajustar a alteração que quebrou a funcionalidade.

Com isso conseguimos entender por que devemos utilizar essas ferramentas.

Vocês devem estar pensando: “eu consigo fazer isso sem o GIT”. Mas acreditem, mesmo com o GIT se tiver um desenvolvedor que não o utiliza direito, você não vai conseguir aproveitar 100% das suas funcionalidades.

Não está convencido? Vou te dar mais um exemplo:

ainda no nosso e-commerce, há 3 meses atrá pediram para tirar o pagamento via boleto por questões legais.

Mas essa semana conseguiram uma nova autorização para gerar boleto em nosso site. Agora vamos precisar reconstruir tudo do zero, certo?

Não! Com GIT conseguimos buscar o histórico de todos os commits (de tudo que foi enviado para ele), buscando pela funcionalidade do boleto, por trecho de código, arquivos, datas e autores. Assim podemos pegar aquela versão que tinha o boleto e implementar na nossa versão atual.

Estas situações, são bem recorrentes, tornando o GIT uma ferramenta muito poderosa no nosso dia a dia.

2 — Como o GIT controla nossas versões?

O GIT trabalha com quatro etapas básicas para o arquivo:

2.1 — Quando criamos um novo arquivo, temos um arquivo não rastreado (Untracked).

2.2 — Quando adicionamos este arquivo no nosso controle de versão, temos um arquivo organizado (Staged e Tracked).

2.3 — Quando o arquivo já existe, temos um arquivo não modificado (Unmodified e Tracked).

2.4 — Quando alteramos um arquivo já existente, temos um arquivo alterado e desorganizado. Desorganizado pois a alteração não foi adicionada no GIT (Modified, Unstaged e Tracked).

Entenda que rastreados (Tracked), são todos os arquivos que foram adicionados ao controle de versão.

Você consegue visualizar este fluxo na imagem abaixo:

Imagem retirada do git-scm, https://git-scm.com/book/en/v2/images/lifecycle.png

3 — Sendo mais prático,

abaixo vamos criar um diretório e iniciar o GIT dentro dele para conseguirmos visualizar as 4 etapas acima:

3.1 — Vamos inicializar o nosso GIT dentro do diretório testeGit com o comando “git init”

git init

3.2- Abaixo estamos criando um novo arquivo chamado “primeiroArquivoVersionado”

touch primeiroArquivoVersionado

3.3- Depois vamos verificar qual o estado do arquivo para o nosso controlador de versão, com o comando “git status”

git status

Este comando nos traz à situação atual do diretório. Acima ele está indicando que criamos um arquivo, porém o mesmo não está sendo rastreado pelo GIT (Untracked).

Além disso o comando acima no diz”: use o comando “git add” para adicionar este arquivo ao commit (que será enviado ao git).

3.4 — Então vamos dizer para o git que ele deve controlar a versão deste arquivo. Em outras palavras vamos transferir a responsabilidade de manter o histórico de alteração deste arquivo para o GIT. Para isso, primeiro devemos utilizar o comando “git add”.

git add primeiroArquivoVersionado

Desta forma estamos organizando os arquivos que o GIT irá controlar.

Vamos verificar o status do diretório para entender o que está acontecendo (Staged).

git status

Neste trecho, o git mostra que nosso arquivo está organizado. Ele está falando que não enviamos nada para ele controlar(No commits yet).

3.5 — Enviando arquivo para o GIT

Depois que organizamos (add) o nosso arquivo, vamos envia-lo com o comando “git commit”

git commit -m “Criado primeiro arquivo versionado”

Pronto! Já temos nosso primeiro arquivo adicionado ao git. Se você reparar no comando de envio (commit) utilizamos o parâmetro “-m” para adicionar uma mensagem junto com a criação do arquivo. Perceba que a mensagem do commit tem que ser objetiva, descrever exatamente o que foi feito nesta alteração. Se precisarmos buscar esta alteração um dia e assim vamos conseguir identificar de forma mais fácil o motivo desta alteração.

Caso a mensagem do seu commit esteja muito grande, precisamos analisar se conseguimos quebrar isso em mais commits.

3.6- Editando arquivo e enviando para o GIT

Agora vamos alterar nosso “primeiroArquivoVersionado”, organizá-lo novamente e enviar para o git.

Alterando arquivo:

echo ‘alterando arquivo versionado’ > primeiroArquivoVersionado

Verificando status do diretório após alteração do arquivo:

git status

No retorno do comando conseguimos ver que o git identificou que o arquivo foi alterado.

Vamos organizar e enviar o arquivo para o git novamente:

git add

O comando (git add .) organiza todos os arquivos que foram alterados e criados dentro do diretório onde o git foi iniciado.

git commit -m “Alterado primeiroArquivoVersionado”

3.7 — Vendo as nossas atividades dentro do versionador.

Agora que enviamos o arquivo vamos verificar tudo que foi enviado para o git com o comando “git log”

git log

Acima conseguimos identificar o horário da alteração, qual arquivo foi alterado e o id único do commit (envio). Caso precisemos ver o que foi alterado em um commit específico podemos utilizar o comando “git show ${id_do_commit}” (${id_do_commit} representa uma variável)

Agora vamos ver o que foi feito no primeiro commit.

Lembrando que o id do commit é único, você terá que substituir o meu código (82012c8bfe6fcf35387a16130c3947197748bc31) pelo o seu (para ver os códigos dos commits utilize o comando “git log”).

git show 82012c8bfe6fcf35387a16130c3947197748bc31

Analisando o retorno do comando “git show”, podemos identificar a descrição ou mensagem que enviamos junto com o arquivo e ainda o que foi feito nesse commit. Em nosso exemplo a criação do arquivo.

Vamos ver o segundo commit (envio)

git show 0f37269b37b78e42e2507df9b0ce2723e52fb3bc

Diferente do primeiro, este mostra a linha que foi adicionada no arquivo seguida pelo sinal de +, além de mostrar a mensagem do commit e o arquivo que foi alterado.

Assim conseguimos ver importância da utilização de um controlador de versão,e ter uma visão de como funciona o processo de versionamento do GIT.

No próximo artigo vamos instalar configurar e subir um projeto do github conhecido como github pages.