# GIT - Comandos

## Comandos básicos/inciais

```sh
# Baixa o repositório/projeto na sua maquina. O projeto será criado em uma pasta de mesmo nome que o repositório.
$ git clone [uri_do_repositorio]

# Para que o projeto seja criado em uma pasta com outro nome basta no fim do comando especificar o nome desejado:
$ git clone [uri_do_repositorio] [nome_da_pasta]
```

```sh
# Obtem as atualizações do repositório e branch remotos:
$ git pull [alias_do_repositorio] [branche_do_repositorio]

# Exemplo:
$ git pull origin master
```

```sh
# Verificar todas as alterações realizadas no repositório referente ao alias:
$ git fetch [alias_do_repositorio]

# Exemplo
$ git fetch origin
```

```sh
# Envia os commits locais para o repositório e branche remotos especificados
$ git push [alias_do_repositorio] [branche_do_repositorio]

# Exemplo:
$ git push origin develop
# Caso a branch develop não exista remotamente ela será criada

# É possível trackear a branch local com a remota que será criada utilizar o parâmetro -u:
$ git push -u origin teste
# (Após trackear a branch quando fizer push e pull não é mais necessário informar o repositório e branch, bastando fazer o git push, por exemplo)
```

```sh
# Adiciona um repositório remoto.
$ git remote add [alias_do_repositorio] [uri_do_repositorio]
# (O alias do repositório remoto por convenção deve-se chamar "origin")
# (A URI é aquela que é oferecida para cada repositório no servidor remoto (Github, Bitbucket, ...))

# Quando utilizamos um git clone não é necessário adicionar um repositório remoto pois o clone já faz isso e já utilizando o alias "origin".
```

## Histórico de Alterações

```sh
# Exibe o histórico dos últimos commits.
$ git log

# com o parametro -p exibe o histórico dos últimos commits exibindo o que foi alterado em cada arquivo:
$ git log -p

# para exibir um resumo dos commits usar o parametro --stat:
$ git log --stat

# também é possível definir a quantidade de informações que serão exbibidas no log com o atributo --pretty passando como parâmetro um das opções: oneline, short, medium, full, fuller, email, raw. Para exibir um commit por linha por exemplo:
$ git log --pretty=oneline

# para exibir um grafico do andamento das branchs e commits é possível utilizar o parâmetro --graph, inclusive pode ser usado em conjunto com outros se preferir:
$ git log --pretty=medium --graph
```

```sh
# Exibe o histórico dos últimos commits mostrando quais arquivos foram alterados.
$ git whatchanged

# É possível incluir o parâmetro -p no final do comando para mostrar também o que foi alterado em cada arquivo:
$ git whatchanged -p
```

```sh
# Exibe quem foi o autor de cada linha do arquivo especificado.
$ git blame [arquivo]
# (Para sair do blame pressione Q)
```

```sh
# Exibe todas as alterações feitas no commit
$ git show [hash_do_commit]

# Exemplo
$ git show b657bcf4f28a8a5c8eea56a3b6eb26e72cc39e39
```

### Customizando o git log
É possível customizar o atributo pretty, por exemplo:
```sh
$ git log --pretty='%an realizou commit em %ad: %s'
```
Onde:
* **%an** -> nome do autor
* **%ad** -> data e hora do commit
* **%s**  -> mensagem do commit

Para outras opções utilizar o git log --help

## Branchs

```sh
# Exibe todas as branchs locais. A branch com um * na frente do nome faz referência a qual branch você se encontra.
$ git branch

# Para ver as branchs remotas inclua o paramêtro -r:
$ git branch -r

# Para ver todas as branches, tanto remoto quanto local usar o parâmetro -a:
$ git branch -a

# Cria uma branch local com o nome especificado.
$ git branch [nome_da_branch]

# Deleta a branch especificada. Pode-se passar também várias branches separadas por espaço.
$ git branch -d [nome_da_branch]

# Criar uma nova branch local trackeada (-t) com uma remota já existente:
$ git branch -t [nome_da_branch] [alias_do_repositorio]/[branche_do_repositorio]

# Exemplo:
$ git branch -t novo origem/novo
```

```sh
# Troca a branch para a especifícada.
$ git checkout [nome_da_branch]

# Se utilizar o parametro -b com o nome de uma branch ele cria a branch e já faz checkout pulando um passo:
$ git checkout -b [nome_da_branch]

# É possível criar uma branch local com o mesmo nome que uma remota e já fazer o checkout para ela com o parâmetro -t e outros detalhes:
$ git checkout -t [alias_do_repositorio]/[branche_do_repositorio]

# Exemplo:
$ git checkout -t origin/tarefa_123

# Deleta uma branch remota:
$ git push [alias_do_repositorio] :[branch_do_repositorio]

#Exemplo:
$ git push origin :minhabranch
```

## Merges

```sh
# Jogar todos os comits da [branch_de_referencia] na frente dos seus commits
### você deve estar na branch que receberá os commits da [branche_de_referencia]
### importante a [branch_de_referencia] estar atualizada (git pull) para ter efeitos redundantes
$ git rebase [branch_de_referencia]

# Exemplo:
$ git rebase master

# Este comando joga commit por commit na sua branch, caso um destes commits de conflito (git status através da informação 'both modified' exibe quais arquivos deram conflito) após resolver o conflito (e adicionarmos com add) usar continue para dar continuidade no rebase:
$ git rebase --continue

## caso desista do rebase e queira voltar como sua branch estava antes use:
$ git rebase --abort

## caso queira descartar o SEU commit que está gerando o conflito usar:
$ git rebase --skip

# Funciona da mesma forma que o rebase tradicional com a diferença que pode ser feito de qualquer lugar não necessariamente da branch de destino.
$ git rebase [branch_de_referencia] [branch_destino]

## Exemplo
$ git rebase master minhabranch
```

```sh
# Faz um merge (trás os últimos commits) da branch_a_mergear para a branch atual
$ git merge [branch_a_mergear]
## normalmente este processo é feito com branches que sairam uma da outra, como mergear a branc X de volta na master pois a X está concluída mas foi criada baseada na master

# Exemplo
$ git merge minhabranch
```

## Desfazer alterações

```sh
# Reverte as modificações de um arquivo que esteja em Working Directory
$ git checkout [nome_do_arquivo]

#Exemplo
$ git checkout MinhaClasse.java

## se por um acaso o arquivo possuir o mesmo nome que uma branch ao invés de reverter o arquivo este comando irá fazer um checkout para a branch, neste caso utilizar --:
$ git checkout -- arquivo

# Copiar um arquivo para que ele fique igual a como ele se encontra em outra branch [nome_branch]
$ git checkout [nome_branch] [nome_do_arquivo]

## Exemplo (deixa o arquivo Teste.java na minha branch igual a como está na master)
$ git checkout master Teste.java
## este comando copia o arquivo e já o deixa no Index pronto para ser commitado
```
```sh
# Remove um commit do Index (colocado após o add) retornando para Working Directory
$ git reset HEAD [nome_do_arquivo]

# Exemplo
$ git reset HEAD meuprojeto/src/com/testes/Classe.java
```

```sh
# Joga tudo o que está no Index e em Working Directory para o stash
$ git stash

# Lista todos os estados que estão no stash
$ git stash list

# Retorna para o código o último estado enviado ao stash e apaga este estado da lista do stash
$ git stash pop

## para retornar um estado especifico do stash e não o último é possível passar o nome do estado:
$ git stash pop stash@{3}

# Tem o mesmo efeito do pop para trazer o último estado ao código porém com a diferença que mantém no stash uma cópia
$ git stash apply

## Para apagar do stash então é necessário utilizar o git stash drop passando o nome do estado a ser removido:
$ git stash drop stash@{0}

## agora se a ideia é só apagar o último basta:
$ git stash drop

## para retornar um estado especifico do stash com o apply e não o último é possível passar o nome do estado:
$ git stash apply stash@{3}

## para 'zerar' o stash pode-se utilizar o comando:
$ git stash clear
```

```sh
# Retorna a base do projeto para o commit do hash informando e todos os commits após este são removidos (do Head) e jogados novamente no código como Working Directory
$ git reset [hash_do_commit]

# Exemplo
$ git reset 12ec2eb6cba5e1021e8ed609ac26188397dc8ed2
# (para saber o hash do commit basta utilizar o git log)

# se desejar trazer diretamente para o index ao Invés de Working Directory utilizar o parâmetro --soft:
$ git reset --soft 12ec2eb6cba5e1021e8ed609ac26188397dc8ed2

# se quiser simplesmente descartar os commits sem trazer o código do commit para o seu código atual usar --hard:
$ git reset --hard 12ec2eb6cba5e1021e8ed609ac26188397dc8ed2
```

==============rever este comando pois não funcionou==============
```sh
# Remove as alterações feitas em um determinado commit abrindo um editor de texto para que possa definir a mensagem do commit de reversão.
$ git revert [hash_do_commit]
# (para saber o hash do commit basta utilizar o git log)

# Exemplo
$ git revert 658ed785d5e5c933d6ccead69b5d1801dd52e331
# (é possível utilizar o comando -n para que as alterações revertidas sejam adicionadas no Working Directory, assim podendo fazer outras alterações e commitar)
```
==============================================================

```sh
# Troca a mensagem do seu último commit. Após executar o comando será pedido a nova mensagem.
$ git commit --amend
```

## Outros

```sh
# Exibe todas as tags do projeto.
$ git tag
```

```sh
# Faz com que o repositório vá para a versão da tag especificada.
$ git checkout [tag]
```

```sh
# Diferenciar duas vesões.
$ git diff [tag1] [tag2]
# (Para sair do diff pressione Q)
```

## Apêndice

### Estados do GIT
* **Working Directory:** arquivo foi alterado mas ainda não foi adicionado ou commitado
* **Index:** arquivo já foi adicionado mas não foi commitado
* **Head:** arquivo já foi commitado

### Alias do GIT
* **HEAD**   -> referencia o último commit
* **HEAD~1** -> referencia o penúltimo commit
* **HEAD~2** -> referencia o antipenúltimo commit
* **HEAD~n** -> e assim por diante

**HEAD^**  -> outra forma de referencia o penúltimo commit (igual a HEAD~1)