Introdução a Controle de Versão com GIT

Prof. Me. Cícero Samuel Clemente Rodrigues

https://forms.office.com/r/D25psWU1ph

Apresentação

Cícero Samuel Clemente Rodrigues
Me. em Engenharia de Software - CESAR School
Esp. em Engenharia de Software - FJN
Tecnólogo em Eletromecânica-CENTEC
Prof. Sistema de Informação há 13 anos
Servidor Federal da UFCA há 7 anos
Senior Developer na Ambevtech há 1 ano

Controle de versão é umas das mais utilizadas ferramentas no desenvolvimento

RebelLabs [2013]

Pra que serve o Controle de Versão?

Situações Comuns

"Essa mudança não deu certo, vamos voltar como estava antes."
"O que mudou nessa rotina? Quando foi essa mudança? Quem é o responsável?"
"Esse defeito já tinha sido corrigido, como apareceu?"
"A nova função que implementei ontem era pra estar aqui mas sumiu."
"Preciso daquela versão que está no cliente. Cadê os arquivos?"
"Como fazer os teste sem para o desenvolvimento?"

Registra a evolução do projeto

Controla a concorrência de edição dos arquivos

Cria e mantém variações do projeto

{

Funções do Controle de Versão

Registrar a evolução do projeto

Precisamos registrar o estado dos arquivos antes de ir para próxima implementação

A solução mais comum é compactar nomeando com a data ou versão

Com o tempo, torna-se impossível a gestão dessas versões...

Registrar a evolução do projeto

Só os backups não bastam!

O que mudou?
Quem mudou?
Quando mudou?

Registrar a evolução do projeto

Trabalho em equipe

Trabalho em Equipe

Provê mecanismos para controle de concorrência:

Travamento
Mesclagem de arquivos
Ramos individuais

Variações de projeto

Como Funciona o Controle de Versão?

Um controle de versão é composto por:

armazena todo o histórico de evolução do projeto, registrando toda e qualquer alteração feita em cada item versionado

contém a cópia dos arquivos do projeto e que é monitorada para identificar as mudanças realizadas

envia modificações feitas gerando uma revisão

atualiza espaço de trabalho a partir de uma revisão

é o estado dos arquivos em determinado momento

(uma fotografia)

é uma configura configuração registrada

Rastreabilidade Bidirecional

Changeset

diferença entre duas configurações

Responde a pergunta

"O que mudou?"

config1

changeset2

config2

changeset2

config2

config1

Conceitos importantes

Configuração é o estado dos arquivos do projeto em um determinado momento

Revisão é uma configuração registrada no repositório

Changeset é o conjunto de diferenças entre duas configurações

Versão é uma revisão usada em produção (Release)

Operações do Controle de Versão

Quais os tipos de Controle de Versão?

Tipo de Controle de Versão

Variam de acordo com o arranjo entre o repositório e espaço de trabalho

Centralizado

Distribuído

Controle de Versão Centralizado

Há um único repositório e várias cópias de trabalho que se comunicam apenas através do repositório central.

Controle de Versão Distribuido

Cada desenvolvedor possui um repositório próprio acoplado a uma área de trabalho.

A comunicação entre eles continua sendo através de commit e update.

Sincronização de Repositórios

pull (puxar)

Atualiza o repositório local (destino) com todas as alterações feitas em outro repositório (origem)

push (empurrar)

Envia as alterações do repositório local (origem) para um outro repositório (destino)

Resumo das operações Básicas

Centralizado	Distribuído	Descrição
checkout	clone	criação da cópia de trabalho/repositório
commit	commit	envia alterações para o repositório, criando uma revisão
update	update checkout fetch	atualiza a cópia/área de trabalho em uma revisão
	pull	importa revisões feita em outro repositório
	push	envia revisões locais para outro repositório

Identificação das Revisões

Numeração sequencial definida a partir da ordem das revisões

Hash SHA-1 a partir de cada configuração

Ex.: Subversion

Ex.: Mercurial e o GIT

Como é o Armazenamento em Controle de Versão

Delta Storage

mantém como um conjunto de arquivos e as mudanças feitas a cada arquivo ao longo do tempo

Snapshot Storage

Conjunto de snapshots de arquivos;
Se foi alterado, o arquivo não é armazenada ( link para o arquivo que já foi armazenado)

Antes de continuar...

Instale o Git

Cadastre-se no GitHub

Instale o vscode

Conhecendo o Git?

O que é o Git?

É um sistema de controle de versão distribuído
Uma das ferramentas de GC mais utilizadas (Rebellabs)
Foi criado por Linus Torvalds como alternativa para manter o Kernel do Linux

The end result was I decided I can write something better than anything out there in two weeks, and I was right.

Tech Talk: Linus Torvalds on git

Existem três componentes em um projeto Git:

Um repositório (repository), onde as mudanças são registradas

Um espaço de trabalho (working directory), onde contém os arquivos que você está trabalhando

Um index ou staging area, onde os commits/revisões são preparadas, comparando os arquivos do working directory e do repository.

Em um fluxo básico do Git

Os arquivos são modificados no espaço de trabalho
As mudanças são preparadas (staged) com o que você deseja incluir no próximo commit.
As mudanças são submetidas, o que as retira do index e as armazena no repositório.

Modified/Untracked

Staged

Commited

Estados no GIT

Fluxos com Repositórios

Vamos a prática!

Onde encontrar a explicação os comandos?

git help

man git

Configurando o ambiente

git config --global user.name "Nome"
git config --global user.email e-mail

Identificação

git config --global core.editor editor

Editor

git config --list

Verificar configurações atuais

Trabalhando localmente

Iniciando um projeto

Para iniciar um repositório Git:

Este comando cria toa a estrutura que o Git necessita para funcionar.

Os arquivos são criados na pasta oculta .git/

git init

Verificando o estado do projeto

O git status exibe as alterações ocorridas no repositório desde o último commit.

git status

Adicionando arquivos

O git add adiciona ou atualiza um arquivo da staging area.

Ou seja, o comando informa ao Git para rastrear o referido arquivo. Caso o arquivo já esteja sob controle do Git, ele o atualiza.

git add arquivo
git add .
git add diretório

Confirmando mudanças

git commit transfere o estado do projeto salvo na staging area para o repositório do projeto.

git commit
git commit -m "descrição do commit"
git commit -am "descrição do commit"

Todo commit deve possuir uma mensagem de identificação, usada para descrever as alterações do commit.

Favor, use-a para tal fim.

Escreva mensagens intuitívas.

Comparando Alterações

O comando git diff compara o estado do repositório atualmente com o estado salvo na staging area

git diff
git diff arquivo
git diff id_commit
git diff id_commit id_commit

O git status informa "quem" foi alterado, mas e se eu quiser saber exatamente "o que" foi alterado?

O comando git diff --cached compara o estado do repositório salvo na staging area com o estado do último commit

git diff --cached

Histórico de Alterações

git log
git log --oneline
git log -p
git log --graph

O comando git log exibe o histórico de commits do projeto

Um pouco mais sobre git log

'Passeando' pelo Projeto

A partir do código associado aos commits você pode voltar para um determinado 'estado' do projeto

git checkout id_commit

O comando git checkout também redireciona arquivos e branches

Desfazendo as modificações

Se eu me arrepender das minhas últimas alterações?

git checkout arquivo
git checkout .

Você pode descartar mudanças no seu working directory voltando o estado dos seus arquivos para o último salvo na staging area.

Desfazendo as modificações

E se eu já adicionei as alterações na staging area?

git reset HEAD arquivo
git reset HEAD .

O comando git reset HEAD devolve as modificações da staging area para o working directory.

Desfazendo as modificações

E se eu já commitei minhas alterações?

1ª Solução: git reset

O comando git reset faz o projeto/arquivo voltar para um estado anterior.

git reset id_commit
git reset arquivo
git reset --hard id_commit

Reflete essa mudança para staging area e work directory

Desfazendo Revertendo modificações

2ª Solução: git reset

O comando git revert não desfaz um commit, mas cria outro removendo a alteração anterior

git revert id_commit

E se eu já commitei minhas alterações?

Removendo arquivos

O comando git rm remove um arquivo do seu projeto.

git rm arquivo
git rm --cached arquivo

A opção --cached remove o arquivo apenas do Git, sem esta opção o comando remove o arquivo do seu computador também.

Ignorando arquivos

Deixar todos os arquivos contidos na pasta do projeto sob controle do Git pode acabar dificultando o gerenciamento, e muitas vezes simplesmente não achamos necessário rastrear alterações de alguns arquivos (arquivos temporários, executáveis e etc...).

O arquivo oculto .gitignore é o responsável por dizer ao Git quais arquivos ele pode ignorar.

Ignorando arquivos

Basta adicionar uma pattern que o Git usará para ignorar os arquivos.
Todos os arquivos que 'casarem' com as patterns serão ignorados.
As patterns seguem o padrão utilizado nos sistemas unix/Linux.

#comentario
* qualquer caractere
! negação
/** subdiretório

Exemplos de patterns e extensões podem ser geradas em gitignore.io

Ramificando a produção de software

O Git permite criar uma linha independente de desenvolvimento no seu projeto. Isto permite alterações em partes especificas do software sem comprometer o restante do projeto.

Ramificando a produção de software

O comando git branch cria um novo branch a partir do último commit.

git branch nome_branch

Navegando entre branches

Além de visualizar commits antigos, o git checkout também é o responsável por alterar o branch corrente.

git checkout nome_branch

Unindo ramificações

Após desenvolvedor uma funcionalidade separada do fluxo principal, muitas vezes é interessante incorporar as modificações no branch master.

O comando git merge uni dois branches novamente, combinando as funcionalidades do branch independente com o branch atual.

git merge nome_branch

Unindo ramificações

Quando não há commits posteriores à criação do branch, a incorporação das funcionalidades ocorre sem nenhum problema.

Unindo ramificações

Porém, quando os branches divergem, o Git precisa que combinar seus conteúdos.

Unindo ramificações

Para informar o trecho conflitante, o Git sinaliza as linhas do arquivo com algumas marcações(<<<<<<<, ======= e >>>>>>>), para corrigir o conflito e confirmar o merge, basta apagar as linhas desnecessárias do arquivo, mantendo conteúdo escolhido, e efetuar um novo commit. Este é basicamente o único trabalho manual que o Git necessita

Merge em novo commit

--no-ff faz com que a mesclagem sempre crie um novo commit.

Deletando ramificações

Após incorporar um branch à outro, pode não ser mais necessário manter uma ramificação. Para deletar um branch utiliza-se do parâmetro -d juntamente com o comando git branch

git branch -d nome_branch

Git Workflow

Branches Principais

Tempo de vida infinito

máster (origin/master)

Reflete o estado do código fonte de produção

develop (origin/develop)

Reflete ultimas mudanças entregues em desenvolvimento
A.k.a.: "Integration Branch"

Branchs de Suporte

Tempo de vida limitado
Desenvolvimento paratelo entre membros da equipe;
facilitar o rastreamento defeatures;
Preparar releases para produção
Correção rápida de problemas "live production"

As branches de suporte comumente usadas são

Feature branches
Release branches
Hotfix branches

Feature Branch

Aka.: "topic branch"
são usadas para desenvolver novos recursos para o lançamento futuro distante ou futuro.
Existem apenas nos repositórios de desenvolvimento do desenvolvedor

Release Branch

Release branches dão suporte à preparação de uma nova liberação(release) de produção.

Utlizadas para pequenas correções de bugs e preparar metadados para uma versão (número da versão, datas de criação, etc.)

Hotfix Branch

Criada quando ocoorre um erro crítico em uma versão de produção
A hotfix é ramificada da tag correspondente na ramificação máster que marca a versão de produção.

Trabalhando com repositórios remotos

Muitas empresas possuem servidores dedicados para suas equipes, mas há algumas soluções no mercados que cumprem a mesma função.

Referenciando um repositório remoto

O comando git remote add é o responsável por referenciar um repositório remoto em um repositório local já existente

O comando git remote rm é utilizado para apagar uma referência à um repositório remoto. Util quando se deseja substituir o local onde o remoto está hospedado.

git remote add origin URL

git remote rm origin

Copiando um repositório remoto

Quando se deseja iniciar/continuar um projeto já existente, utiliza-se dogit clone para copiar todo um repositório remoto para uma máquina local.

git clone URL

Baixando conteúdo do remoto

O Git disponibiliza duas maneiras de baixar as atualizações de um repositório remoto. O comando git fetch baixa as atualizações mas não as incorpora ao repositório local.

git fetch
git fetch origin master
git fetch origin nome_branch

Baixando conteúdo do remoto

Outra maneira é utilizando o comando git pull, que baixa e incorpora as modificações no repositório local. Equivale à um git fetch seguido de uma git merge.

git pull
git pull origin master
git pull origin nome_branch

Trabalhando com Versões

Versão

Revisão

Release

Pode se tornar uma

O que é uma release?

Um release de sistema é uma versão de um sistema de software distribuída aos clientes. (Sommerville, 2011).

Versionamento Semânico

Dado um número de versão MAJOR.MINOR.PATCH, incremente a:

versão Maior(MAJOR): quando fizer mudanças incompatíveis na API,

versão Menor(MINOR): quando adicionar funcionalidades mantendo compatibilidade, e

versão de Correção(PATCH): quando corrigir falhas mantendo compatibilidade.

Rótulos adicionais para pré-lançamento(pre-release) e metadados de construção(build) estão disponíveis como extensão ao formato MAJOR.MINOR.PATCH.

https://semver.org/lang/pt-BR/

Versionamento Semânico

Criando Versões

Conforme incluímos funcionalidades no sistema, podemos definir pontos relevantes no software, que geralmente, marcam uma versão de lançamento.
O comando git tag inclui um rótulo à um determinado commit para que este possa ser referenciado mais facilmente.

git tag -a versao -m "descrição"

Compartilhando Versões

Para visualizar as versões ja criadas, utilize git tag.

git tag

Por padrão, o comando git push não transfere tags
Você deve enviar as tags explicitamente – você executa git push origin [nome-tag].

git push origin v1.5

se deseja enviar muitas tags ao mesmo tempo digite:

git push origin --tags

Referências

CHACON, Scott; STRAUB, Ben. Pro git. Apress, 2014.

DIAS, A. F. Conceitos Básicos de Controle de Versão de Software-Centralizado e Distribuído. 2011. 2013.

KREEFTMEIJER, Jeff. Using git-flow to automate your git branching workflow. 2015.

PRESTON-WERNER, Tom. Semantic Versioning 2.0.0. URL: https://semver. org, 2013.

SOMMERVILLE, Ian. Software engineering 9th Edition. ISBN-10137035152, 2011.