Git

Compilei esse resumão do curso da Alura sobre o Git. No momento ele funciona como um guia de referência sobre os tópicos a serem estudados, mas quero deixar mais ágil. Minha idéia é criar três partes, conceito, miscelânea de códigos e exercícios.

https://git-school.github.io/visualizing-git/ - Ferramentas para visualizar os comandos git
https://git-scm.com/book/pt-br/v2/Fundamentos-de-Git-Gravando-Alterações-em-Seu-Repositório - ver depois

01 O que é Git?

O que são (e para que servem) sistemas de controle de versões e como eles podem ajudar o nosso fluxo de desenvolvimento
- Nos ajudam a manter um histórico de alterações;
- Nos ajudam a ter controle sobre cada alteração no código;
- Nos ajudam para que uma alteração de determinada pessoa não influencie na alteração realizada por outra;
- Etc.
Que com o comando git init nós conseguimos criar um repositório Git;
Como analisar o estado do nosso repositório através do comando git status.

02 Iniciando os trabalhos

02A Para saber mais: Quem é você

Antes de qualquer interação com o git, você precisa informar quem é você para que ele armazene corretamente os dados do autor de cada uma das alterações no código.

Basta digitar os seguintes comandos (estando na pasta do repositório git):

git config --local user.name "Seu nome aqui"
git config --local user.email "seu@email.aqui"

02B Para saber mais: git status

Ao executar o comando git status, recebemos algumas informações que talvez não estejam tão claras, principalmente quando nos deparamos com termos como HEAD, working tree, index, etc.

HEAD: Estado atual do nosso código, ou seja, onde o Git os colocou
Working tree: Local onde os arquivos realmente estão sendo armazenados e editados
index: Local onde o Git armazena o que será commitado, ou seja, o local entre a working tree e o repositório Git em si.

Além disso, os possíveis estados dos nossos arquivos são explicados com detalhes neste link: <https://git-scm.com/book/pt-br/v2/Fundamentos-de-Git-Gravando-Altera%C3%A7%C3%B5es-em-Seu-Reposit%C3%B3rio.

02C Para saber mais: git log

git log - podemos visualizar o histórico de alterações em nosso projeto.

Apesar de ser fácil, este comando é muito poderoso. Execute git log --help e veja algumas das opções possíveis. Para alguns exemplos mais fáceis de entender, você pode pesquisar sobre git log ou dar uma olhada neste link: https://devhints.io/git-log.

02D Para saber mais: Quando commitar

Devemos gerar um commit sempre que a nossa base de código está em um estado do qual gostaríamos de nos lembrar. Nunca devemos ter commits de códigos que não funcionam, mas também não é interessante deixar para commitar apenas no final de uma feature.

02E O que apendemos?

Que um commit é a forma de salvar um estado ou versão do nosso código;
Como adicionar arquivos para serem commitados com git add;
Como commitar arquivos, utilizando o comando git commit;
Como verificar o histórico de commits, através do git log e algumas de suas opções:
- git log --oneline
- git log -p
- git log --pretty="parametros de formatação"
Como fazer o Git não monitorar arquivos, através do .gitignore
Que não devemos realizar commit, ou seja, salvar um estado, da nossa aplicação que não esteja funcionando.

03 Compartilhando o trabalho

03A Para saber mais: GitHub

No último vídeo, nós conhecemos (bem por alto) um dos serviços mais famosos e utilizados por pessoas que desenvolvem software: o GitHub.

Com o GitHub, podemos ter repositórios remotos públicos e privados gratuitos para armazenar e compartilhar o código dos nossos projetos.

O GitHub fornece muitas outras funcionalidades bem legais. Explore-as, brinque com elas, e em outros cursos aqui na Alura nós vamos falar mais sobre esse assunto.

03B O que aprendemos?

O que são repositórios remotos;
Como criar um repositório Git sem uma cópia dos arquivos (com --bare) para ser utilizado como servidor;
Como adicionar links para os repositórios remotos, com o comando git remote add;
Como baixar um repositório pela primeira vez, clonando-o com o comando git clone;
Como enviar as nossas alterações para um repositório remoto, com git push;
Como atualizar o nosso repositório com os dados no repositório remoto, utilizando git pull;
O que é e para que serve o GitHub;
Como criar um repositório no GitHub;
Como adicionar um repositório do GitHub como repositório remoto.

04 Trabalhando em equipe

04A Para saber mais: Ramificações

Branches (“ramos”) são utilizados para desenvolver funcionalidades isoladas umas das outras. A branch master é a branch “padrão” quando você cria um repositório.

É interessante separar o desenvolvimento de funcionalidades em branches diferentes, para que as mudanças no código para uma não influencie no funcionamento de outra.

04B Para saber mais: Conflitos com rebase

Vimos como é simples resolver conflitos identificados pelo Git ao tentar realizar o merge.

Agora, gere um conflito e, ao invés de utilizar o merge, utilize o rebase para atualizar o master:

Vá para a branch titulo
Commite algo
Vá para a branch master, commite uma alteração na mesma linha
Execute git rebase titulo

Veja a saída do Git e utilize as informações que ela te der para, após corrigir o conflito, continuar o rebase.

04C O que aprendemos?

Que uma branch (ou ramo) é uma linha de commits separada, e que pode ser utilizada para desenvolver funcionalidades independentes;
Que com branches separados, podemos evitar que o código de uma funcionalidade interfira em outra;
Como trazer o trabalho realizado em uma branch para outra branch, como por exemplo, o master, através do comando git merge;
Que o git merge gera um novo commit, informando que houve uma mescla entre duas branches;
Como trazer os commits de uma branch para outra, com o git rebase
Que o git rebase não gera um commit de merge, simplificando o nosso log;
Como os conflitos são apresentados pelo Git;
Como resolver os conflitos e manter apenas as alterações desejadas com o Git.

05 Manipulando as versões

Que o Git pode nos ajudar a desfazer alterações que não vamos utilizar;
Que, para desfazer uma alteração antes de adicioná-la para commit (com git add), podemos utilizar o comando git checkout -- <arquivos>;
Que, para desfazer uma alteração após adicioná-la para commit, antes precisamos executar o git reset HEAD <arquivos> e depois podemos desfazê-las com git checkout -- <arquivos>;
Que, para revertermos as alterações realizadas em um commit, o comando git revert pode ser a solução;
Que o comando git revert gera um novo commit informando que alterações foram desfeitas;
Que, para guardar um trabalho para retomá-lo posteriormente, podemos utilizar o git stash;
Que, para visualizar quais alterações estão na stash, podemos utilizar o comando git stash list;
Que, com o comando git stash apply <numero>, podemos aplicar uma alteração específica da stash;
Que o comando git stash drop <numero> remove determinado item da stash;
Que o comando git stash pop aplica e remove a última alteração que foi adicionada na stash;
Que o git checkout serve para deixar a cópia do código da nossa aplicação no estado que desejarmos:
- git checkout <branch> deixa o código no estado de uma branch com o nome <branch>;
- git checkout <hash> deixa o código no estado do commit com o hash <hash>.

06 Gerando entregas

Que é possível visualizar quais alterações foram realizadas em cada arquivo, com o comando git diff;
Que, digitando apenas git diff, vemos as alterações em nossos arquivos que não foram adicionadas para commit (com git add);
Que é possível comparar as alterações entre duas branches com git diff <branch1>..<branch2>
Que é possível comparar as alterações feitas entre um commit e outro, através do comando git diff <commit1>..<commit2>;
Que o Git nos possibilita salvar marcos da nossa aplicação, como por exemplo, lançamento de versões, através do git tag;
Que o comando git tag -a é utilizado para gerar uma nova tag;
As Releases do GitHub, que são geradas para cada tag do Git criada em nosso repositório.

Exercício 01

Crie uma pasta (onde preferir) e dentro dela salve o arquivo index.html, com o seguinte conteúdo:

 1<!DOCTYPE html>
 2<html lang="en">
 3<head>
 4    <meta charset="UTF-8">
 5    <title>Cursos da Alura</title>
 6</head>
 7<body>
 8    <ul>
 9        <li>Vagrant</li>
10        <li>Docker</li>
11        <li>Ansible</li>
12        <li>Integração Continua</li>
13    </ul>
14</body>
15</html>

No terminal (ou Git Bash, no Windows) navegue até a pasta recém criada (utilize o comando cd para navegar entre pastas);
Na pasta do projeto, execute o comando git init para inicializar um repositório Git;
Execute o comando git status para garantir que você está em um repositório Git e que o arquivo index.html é reconhecido. Leia com calma a saída deste comando. Nem tudo estará claro ainda, mas durante o treinamento ficará!

Exercício 02

No terminal (ou Git Bash, no Windows) navegue até a pasta recém criada (utilize o comando cd para navegar entre pastas);
Execute o comando git add index.html para marcar o arquivo para ser salvo (commitado);
Execute git status e confira que o arquivo agora mudou de estado e está pronto para ser salvo (commitado);
Após adicionar, execute o comando git commit -m "Criando arquivo index.html com lista de cursos". Sinta-se à vontade para alterar a mensagem de commit, se desejar;
Altere o arquivo index.html. Adicione o acento em “Integração Continua”, por exemplo;
Adicione o arquivo para ser salvo, com git add .;
Execute o comando git commit -m "Acento adicionado no curso de Integração Contínua". Sinta-se à vontade para alterar a mensagem de commit, se desejar;
Execute o comando git log e analise a sua saída. Execute também git log --oneline, git log -p e outras alternativas que quiser testar;
Crie um arquivo vazio com o nome que quiser, por exemplo, ide-config;
Crie o arquivo .gitignore e adicione uma linha com o nome do arquivo recém-criado (ide-config, no exemplo acima);
Execute git status e verifique que o arquivo ide-config não está na lista para ser adicionado;
Adicione (com git add .gitignore) e realize o commit (com git commit -m "Adicionando .gitignore") o arquivo .gitignore.

Exercício 03

Crie uma pasta nova em seu computador;
No terminal (ou Git Bash, no Windows) navegue até a pasta recém criada (utilize o comando cd para navegar entre pastas);
Execute o comando git init --bare;
Navegue até a pasta onde se encontra o seu projeto;
Execute o comando git remote add local {caminho}. Substitua {caminho} pelo caminho completo da pasta recém criada;
Crie uma nova pasta em seu computador, para representar o trabalho de outra pessoa;
No terminal (ou Git Bash, no Windows) navegue até a pasta recém criada;
Execute o comando git clone {caminho} projeto. Substitua {caminho} pelo caminho completo da pasta que criamos no primeiro passo;
Observe que o repositório clonado está vazio;
Acesse a pasta Projeto e execute o comando ‘git remote rename origin local’ para renomear o repositório local da outra pessoa de “origin” para “local”;
Navegue até a pasta onde se encontra o seu projeto original;
Execute o comando git push local main para enviar as suas modificações para o seu servidor;
Navegue até a pasta criada no passo 6;
Execute o comando git pull local main para baixar as modificações;
Abra o seu navegador e acesse http://github.com/;
Crie uma conta;
Crie um novo repositório, clicando no símbolo de adição no canto superior direito;
No terminal (ou Git Bash, no Windows) adicione, ao seu projeto inicial, o repositório remoto recém criado (os comandos são mostrados pelo próprio GitHub);
Execute git push origin main para enviar as suas alterações para o repositório no GitHub.

Exercício 04

Execute o comando git branch e veja que apenas a branch master existe no seu repositório;
Execute o comando git branch titulo e logo após execute o comando git branch. Veja que uma nova branch foi criada;
Agora, para começar a trabalhar nesta branch, digite git checkout titulo;
Execute novamente git branch e confira que agora você está na branch chamado titulo;
Altere o título da página index.html para “Cursos de DevOps da Alura”;
Adicione as alterações com git add index.html;
Faça o commit, com git commit -m "Alterando título da página";
Execute o comando git log e confira o novo commit;
Altere o título da página para “Lista de cursos de DevOps da Alura”;
Repita os passos 6 e 7, para adicionar um novo commit, alterando a mensagem;
Repita o passo 8 para conferir o novo commit;
Execute o comando git checkout master para voltar à linha de desenvolvimento master;
Execute git log para conferir que os últimos dois commits não estão lá. Confira se o conteúdo do seu arquivo também voltou ao seu estado original;
Na pasta criada para representar o trabalho de outra pessoa na aula anterior:

Execute git checkout -b lista para criar uma nova branch, chamada lista e passar a trabalhar nela;
Adicione o curso de “Kubernetes” na lista;
Repita os passos 6 e 7 para adicionar um novo commit, alterando a mensagem;
Execute o comando git checkout master para voltar à linha de desenvolvimento master;

Volte para a pasta que representa o seu próprio trabalho;
Altere o nome do curso de Docker para “Docker: Criando containers sem dor de cabeça”;
Repita os passos 6 e 7 para adicionar um novo commit, alterando a mensagem;
Execute o comando git merge titulo para trazer o trabalho feito na branch titulo para a branch master;
Execute o comando git log --graph para ver as linhas de desenvolvimento (branches);
Execute git checkout titulo para trabalhar na branch chamada titulo;
Altere o título para ter a palavra “Cursos” com letra maiúscula;
Repita os passos 6 e 7 para adicionar um novo commit, alterando a mensagem;
Execute o comando git checkout master para voltar à linha de desenvolvimento master;
Execute o comando git rebase titulo;
Execute o comando git log e confira que o commit foi adicionado antes do commit realizado diretamente na branch master;
Execute o comando git push local master para enviar suas alterações para o repositório remoto que criamos na última aula;
Na pasta criada para representar o trabalho de outra pessoa na aula anterior:

Execute o comando git pull local master para baixar as alterações que você já realizou;
Execute o comando git checkout lista para continuar trabalhando na lista de cursos;
Altere o nome do curso de Docker para “Curso de Docker: Criando containers sem dor de cabeça”;
Repita os passos 6 e 7 para adicionar um novo commit, alterando a mensagem;
Execute o comando git checkout master para voltar à linha de desenvolvimento master;
Tente juntar seu trabalho com git merge lista;
Veja que há conflitos. Corrija-os, deixando apenas a linha com o nome correto do curso;
Execute o comando git add index.html para informar que os conflitos neste arquivo foram corrigidos;
Execute o comando git commit para que o Git finalize o merge;
Execute o comando git push local master para enviar as suas alterações;

Volte para a pasta que representa o seu próprio trabalho;
Altere o nome do curso de Vagrant para “Vagrant: Gerenciando máquinas virtuais”;
Repita os passos 6 e 7 para adicionar um novo commit, alterando a mensagem;
Tente executar o comando git push local master. Veja a falha;
Execute o comando git pull local master para trazer as alterações da outra pessoa;
Agora sim, execute o comando git push local master para enviar as alterações.

Exercício 05

Na pasta que representa o seu projeto, faça uma alteração qualquer no arquivo index.html;
Execute o git status e veja que há uma alteração para adicionar;
Execute o comando git checkout -- index.html. Confira se sua alteração foi desfeita;
Novamente, faça alguma alteração no arquivo index.html;
Execute o comando git add index.html;
Execute o comando git reset HEAD index.html para trazer o arquivo index.html de volta para a HEAD do projeto (remover do stage, que é o que será enviado para o commit);
Repita o passo 3;
Faça mais uma vez alguma alteração no código;
Execute o comando git add index.html e o comando git commit -m "Alterando o código" para realizar um commit;
Execute o comando git log e copie o hash deste commit recém criado;
Rode o comando git revert {hash}, substituindo {hash} pelo hash que você copiou anteriormente;
Confira que suas alterações foram desfeitas;
Mude o nome do curso de Ansible para “Ansible: Infraestrutura como código”;
Execute o comando git stash para salvar estas alterações na stash;
Altere o nome do curso de Kubernetes para “Kubernetes: Introdução a orquestração de containers”;
Execute o comando git add index.html e o comando git commit -m "Alterando o nome do curso de Kubernetes" para realizar um commit;
Execute o comando git stash pop para trazer a última alteração da stash;
Execute o comando git add index.html e o comando git commit -m "Alterando o nome do curso de Ansible" para realizar um commit;
Execute o comando git push local master para enviar todas as suas alterações;
Execute o comando git log --oneline para ver os commits de forma resumida. Copie o hash do commit de merge com a branch lista;
Execute o comando git checkout {hash} substituindo {hash} pelo hash que você copiou;
Veja que diversas alterações não estão mais presentes;
Execute git checkout master para voltar à linha principal de desenvolvimento.

Exercício 06

Execute o comando git log -p para ver, junto a cada commit, as alterações nele realizadas;
Execute agora o comando git log --oneline;
Execute o comando git diff {hash do commit de merge com lista}..{hash do último commit realizado};
Execute alguma (pequena) alteração no index.html;
Execute o comando git diff e veja esta alteração;
Desfaça esta última alteração;
Execute o comando git tag -a v0.1.0 para criar uma tag no seu código;
Execute o comando git push origin v0.1.0 para enviar esta tag para o GitHub;
Abra a página do repositório do GitHub que você criou e confira a aba de Releases.

Fonte: Curso de Git da Alura - 20210901