Aprenda a usar o Git com o Bitbucket Cloud

Aprenda a fazer branches com o Bitbucket Cloud

Fique com tudo pronto Confira o fluxo de trabalho de branch

Objetivo

Este tutorial ensina os passos básicos para criar, analisar, mesclar e trabalhar em branches a partir do Git e do Bitbucket Cloud.

Tempo	Público	Pré-requisitos
35 minutos	Quem conhece os passos básicos do fluxo de trabalho no Git	Ter instalado o Git
		Ter uma conta do Bitbucket

Este tutorial é para você se já entende o fluxo de trabalho básico do Git, que inclui como:

Clonar: copiar o repositório remoto no Bitbucket Cloud para o sistema local
Adicionar ou preparar: pegar modificações que você fez e as preparar para adicionar ao histórico do Git
Confirmar: adicionar arquivos novos ou modificados ao histórico do Git para o repositório
Enviar pull: ver novas modificações que outros adicionaram ao repositório no seu repositório local
Fazer push: fazer modificações do sistema local para o repositório remoto

Se você não conhece os passos básicos do Git, não se preocupe: confira o tutorial Aprenda o Git com Bitbucket Cloud e você vai estar com tudo pronto para acelerar com rapidez.

Por que ramificar é importante

Ramificar é uma das melhores formas de aproveitar ao máximo o Git para ter controle sobre as versões. Ramificar no Git permite que você:

Tenha várias equipes trabalhando em um único repositório ao mesmo tempo.
Tenha membros da equipe em qualquer lugar do mundo usando o Bitbucket Cloud para colaborar.
Tenha várias linhas de desenvolvimento em execução ao mesmo tempo, independentes umas das outras, sem a necessidade de congelamentos de código.

Fique com tudo pronto

Como a gente quer que você sinta que está trabalhando em equipe, em um repositório comum do Bitbucket, a gente pede que você bifurque um repositório público que a gente já forneceu.

O que é uma bifurcação?

Bifurcação é outra forma de salvar um clone ou copiar. O termo "bifurcar" (em programação) se deriva de um chamado do sistema Unix que cria uma cópia de um processo existente. Assim, diferente de um branch, uma bifurcação é independente do repositório original. Se o repositório original for excluído, a bifurcação permanece. Se você bifurcar um repositório, vai ficar com esse repositório e todos os branches.

Acesse tutorials/tutorials.git.bitbucket.org
Clique em + > Bifurque este repositório no lado esquerdo da tela.
Modifique o Nome para que seja exclusivo da equipe e clique em Bifurcar o repositório.
Crie um diretório para o repositório que vai ser fácil de navegar. Você pode escolher algo assim:
```
$ mkdir test-repositories
$ cd test-repositories/
$ test-repositories
```
O exemplo anterior cria o diretório test-repositories usando o comando mkdir (criar diretório) e entra nesse diretório usando o comando cd (mudar de diretório).

Clone o repositório bifurcado no diretório que acabou de criar. Ele pode se parecer assim:

$ git clone https://dstevenstest@bitbucket.org/dstevenstest/mygittutorial.bitbucket.io.git
    Cloning into 'mygittutorial.bitbucket.io'...
    remote: Counting objects: 12392, done.
    remote: Compressing objects: 100% (12030/12030), done.
    remote: Total 12392 (delta 8044), reused 564 (delta 360)
    Receiving objects: 100% (12392/12392), 2.72 MiB | 701.00 KiB/s, done.
    Resolving deltas: 100% (8044/8044), done.
$ cd mygittutorial.bitbucket.io/

Isso clona o repositório usando o comando git clone e cria o diretório que o clone criou mygittutorial.git.bitbucket.io.

Crie um branch e modifique algo usando o fluxo de trabalho com branches

Você vai adicionar uma cotação ao seu site nesse branch.

Crie um branch usando o comando git branch.
```
$ git branch test-1
```
Verifique o branch que acabou de criar usando o comando git checkout.
```
$ git checkout test-1
Switched to branch 'test-1'
```
Liste os branches que você tem no local usando o comando git branch.
```
$ git branch
  master
  * test-1
```

Faça uma atualização no arquivo editme.html adicionando uma cotação. Você pode usar algo assim:

<div class="quote">
  <blockquote>Esta é uma cotação e gosto dela.</blockquote>
  <cite>Uma cotação: a arte de cotar</cite>
</div>

Adicione essa alteração.
```
git add editme.html
```
Observação: a alteração não é confirmada no histórico do Git, pois ainda está em estado "aguardando". A gente aprendeu isso em Como salvar alterações.
Confirme a alteração com uma mensagem de commit descritiva.
```
git commit editme.html -m'added a new quote'
[test-1 063b772] added a new quote
1 file changed, 3 insertions(+), 3 deletions(-)
```
Observação: agora as alterações são parte do histórico do Git como um "commit" simples A gente aprendeu isso em Como salvar alterações.
Envie essa alteração por push ao Bitbucket usando o comando git push.
```
git push
fatal: o branch test-1 atual não tem um branch a montante.
Para enviar o branch atual e definir o remoto como a montante, use
  git push --set-upstream origin test-1
```
Você vai ver um erro porque a primeira vez que enviou um branch novo que criou no local, você tem que designar esse branch.

Envie o branch e o altere usando o comando git push branch.

$ git push origin test-1
Counting objects: 3, done.
Delta compression using up to 8 threads.
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 363 bytes | 0 bytes/s, done.
Total 3 (delta 2), reused 0 (delta 0)
remote:
remote: Create pull request for test-1:
remote: https://bitbucket.org/dstevenstest/dans.git.bitbucket.org/pull-requests/new?source=test-1&t=1
remote:
To https://bitbucket.org/dstevenstest/dans.git.bitbucket.org.git
* [new branch] test-1 -> test-1

Isso informa ao sistema de que o repositório de origem é o destino desse branch novo.

Abra o repositório de tutoriais e clique em Branches. Você deve agora ver os branches mestres e test-1. Eles são assim:

Crie, capture e verifique um branch remoto

Ao trabalhar em uma equipe, é possível que tenha de enviar pull ou buscar branches que outros membros da equipe criam e fazem push no Bitbucket. Este exemplo vai dar a você alguns dos passos básicos para criar e trabalhar com branches que outros criaram.

Acesse o repositório de tutoriais no Bitbucket e clique em Branches. Você deve ver algo assim:
Clique em Criar branch, dê o nome test-2 e clique em Criar.

Copie o comando git fetch ao fechar a caixa de diálogo do branch. Ela vai ser exibida com algo assim:

$ git fetch && git checkout test-2
From https://bitbucket.org/dstevenstest/dans.git.bitbucket.org
* [new branch] test-2 -> origin/test-2
Branch test-2 set up to track remote branch test-2 from origin.
Switched to a new branch 'test-2'

Use o comando git branch no terminal. Você deve ver uma lista de branches assim:
```
$ git branch
  master
  test-1
* test-2
```
O branch com o asterisco * é o que está ativado. Isso é crucial lembrar quando estiver trabalhando em qualquer fluxo de trabalho de branch.
Use o comando git status e você vai ver algo assim:
```
$ git status
On branch test-2
Your branch is up-to-date with 'origin/test-2'.
nothing to commit, working tree clean
```
Você pode ver em qual branch está e que ele está atualizado com o branch remoto (origem).
Use o comando git checkout para mudar o foco de volta para o outro branch. O comando vai ser mais ou menos assim:
```
$ git checkout test-1
Switched to branch 'test-1'
Your branch is ahead of 'origin/test-1' by 3 commits.
(use "git push" to publish your local commits)
```
Uma das coisas mais importantes a ser lembrada ao trabalhar em branch é que você quer estar certo de que o branch em que está fazendo alterações é o certo.

Modifique por push e crie uma solicitação pull

Agora é o momento de fazer com que a primeira alteração seja revisada e mesclada no branch.

Clique em +> Criar solicitação pull. Você pode ver o branch test-1 como o branch de origem e principal no de destino.

Como a gente criou esse repositório bifurcando um repositório atual, o destino é definido como o branch principal do repositório que a gente bifurcou.

Para corrigir isso, você vai ter que alterar o branch de destino do repositório (o branch em que você vai mesclar as alterações) a partir de tutorials/tutorials.git.bitbucket.org no repositório.

Você também adiciona revisores à equipe na solicitação pull. Saiba mais sobre solicitações pull
Clique em Criar solicitação pull.
Faça um comentário na solicitação pull selecionando uma linha na diff (a área exibindo a alteração que você fez no arquivo editme.html).
Clique em Aprovar na parte superior esquerda da página. É claro que em uma solicitação pull verdadeira você teria revisores fazendo comentários
Clique em Mesclar.
(Opcional) Atualize a Mensagem de commit com mais dados.
Selecione a Mensagem de commit Estratégia de merge dentre as duas opções:
- Merge de commit: mantém todos os commits do branch de origem e as torna parte do branch de destino. Essa opção é o mesmo que digitar git merge --no-ff na linha de comando.
- Squash: combina os commits quando você mescla o branch de origem no de destino. Essa opção é o mesmo que digitar git merge --squash na linha de comando.
Saiba mais para ver os dados desses dois tipos de estratégias de merge.
Clique em Commits e você vai ver como o branch que acabou de mesclar se encaixa no esquema mais amplo de alterações.

Exclua um branch e envie um pull mestre para o branch de trabalho local

Você passou pelo fluxo de trabalho básico de branch, e a modificação está no principal. A última coisa que a gente vai aprender é a excluir o branch que você acabou de mesclar, enviar o branch principal atualizado por pull e mesclar esse branch no test-2.

Por que excluir o branch?

Ramificar no Git é diferente dos sistemas de controle de versão SVN ou semelhantes ao usar branches como os de execução longa, por exemplo, um branch principal ou de desenvolvimento, e os de desenvolvimento a curto prazo, como os exemplos que a gente usa neste tutorial. Como este é o caso, não é uma má ideia excluir os branches locais para manter o ambiente local mais organizado.

Por que enviar o mestre por pull e o mesclar com o test-2?

A gente usa isso como exemplo de você trabalhando em um repositório em que outro membro da equipe está trabalhando. É uma boa ideia fazer modificações para o branch de trabalho de vez em quando para evitar conflitos de merge nas solicitações pull.

Abra o terminal e execute o comando git status. O resultado deve ser algo assim:
```
$ git status
On branch test-1
nothing to commit, working tree clean
```
Você pode ver que está no branch que acabou de usar para fazer a alteração e que você não tem nenhuma alteração. Está na hora de se livrar desse branch já que o trabalho está feito.
Mude para o branch principal executando o comando git checkout master. O resultado deve ser algo assim:
```
git checkout master
Switched to branch 'master'
Your branch is up-to-date with 'origin/master'.
```
Observe que a mensagem diz que você está atualizado. Isso é apenas o branch local. A gente sabe disso porque acabou de mesclar uma alteração no branch principal e não fez envio pull dessa alteração desde o repositório remoto em nosso sistema local. É isso o que a gente vai fazer.

Execute o comando git pull. O resultado deve ser algo assim:

$ git pull
remote: Counting objects: 1, done.
remote: Total 1 (delta 0), reused 0 (delta 0)
Unpacking objects: 100% (1/1), done.
From https://bitbucket.org/dstevenstest/dans.git.bitbucket.org
2d4c0ab..dd424cb master -> origin/master
Updating 2d4c0ab..dd424cb
Fast-forward
editme.html | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)

O que aconteceu é que, quando você envia pull das alterações desde o repositório remoto, o git executa um merge retroativo para integrar as alterações que você fez. Ele também lista quantos arquivos e linhas nesse arquivo foram alterados.

Execute o comando git branch -d {branch_name} para remover o branch test-1. O resultado deve ser algo assim:
```
$ git branch -d test-1
Deleted branch test-1 (was 063b772)
```
Você pode ver que isso excluiu o branch e que o último hash de commit foi para esse branch. Esta é a maneira segura de excluir um branch, porque o git não vai permitir que você exclua o branch se ela tiver alterações não confirmadas. No entanto, você deve estar ciente que isso não vai evitar a exclusão de alterações que são confirmadas no histórico do git, mas não mescladas em outro branch.

Mude para o branch test-2 usando o c comando git checkout.

$ git checkout test-2
Switched to branch 'test-2'
Your branch is up-to-date with 'origin/test-2'.

Mescle o branch principal e o branch de trabalho usando o comando git merge master test-2. O resultado vai ser algo assim:
```
$ git merge master test-2
Updating 2d4c0ab..dd424cb
Fast-forward
editme.html | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)
```
É importante se lembrar que:
- O branch ativo é importante. Se você quer mesclar o branch principal em test-2, então quer que test-2 seja verificado (ativo). Isso também se aplica se você quer mesclar test-2 no branch principal: você precisa que o branch principal seja verificado.
- Para ver quando quiser qual branch está ativo, use git branch e o branch ativo vai ter um asterisco ou, ainda use git status e ele vai informar em que branch você está e se há alterações locais pendentes.

A gente espera que você tenha aprendido um pouco sobre branches e os comandos envolvidos. Vamos revisar alguns conceitos:

Confira o fluxo de trabalho de branch

O fluxo de trabalho de branches de recurso do Git é uma forma eficiente de começar a trabalhar com a equipe no Bitbucket. Nesse fluxo de trabalho, todo o desenvolvimento de recursos ocorre em branches separados do branch principal mestre. Assim, vários desenvolvedores podem trabalhar nos próprios recursos sem encostar no código principal.

Comece com o branch principal

Este fluxo de trabalho ajuda a colaborar no código com pelo menos outra pessoa. Desde que os repositórios locais e do Bitbucket estejam atualizados, você está pronto para começar.

Crie um branch novo

Use um branch separado para cada recurso ou item em que você trabalha. Depois de criar um branch, verifique no local para que quaisquer modificações que você fizer estejam nesse branch.

Atualize, adicione, confirme e faça push de modificações

Trabalhe no recurso e faça commits como sempre faz quando usa o Git. Quando estiver pronto, envie os commits por push, atualizando os branches de recurso no Bitbucket.

Faça com que o código seja analisado

Para ter um feedback do código, crie uma solicitação pull no Bitbucket. A partir daí, você pode adicionar revisores e confirmar que tudo está bem antes de mesclar.

Resolva o feedback

Agora, seus colegas comentam e aprovam. Resolva os comentários deles no local, confirme e faça push das modificações para o Bitbucket. As atualizações aparecem na solicitação pull.

Mescle o branch

Antes de mesclar, você pode ter que resolver conflitos de merge se outros fizeram modificações no repositório. Quando a solicitação pull for aprovada e não tiver conflitos, você pode adicionar o código ao branch principal. Mescle a partir da solicitação pull no Bitbucket.

Este tutorial é limitado à capacidade de mostrar como os branches tornam as equipes mais eficientes. Há diferentes formas de ramificar, e a gente vai ver algumas delas em: Como comparar fluxos de trabalho.