Aprenda a usar o Git com o Bitbucket Cloud

Aprenda a fazer branches com o Bitbucket Cloud

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-alvo: Pré-requisitos
35 minutos Você já entende o fluxo de trabalho básico do Git Você instalou o Git
Você tem uma conta Bitbucket

Este tutorial é para pessoas que já conhecem o fluxo de trabalho básico do Git, incluindo como:

  • Clonar: copiar o repositório remoto no Bitbucket Cloud para o sistema local
  • Adicionar ou preparar: pegar as alterações que você fez e as preparar para adicionar ao histórico do Git
  • Commit: adicionar arquivos novos ou modificados ao histórico do Git para o repositório
  • Enviar pull: ver novas alterações que outros adicionaram ao repositório no seu repositório local
  • Push: obter alterações de seu sistema local no repositório remoto

Se você não conhece os fundamentos do Git, não se preocupe: confira o tutorial Aprenda o Git com Bitbucket Cloud e você vai estar preparado para começar em pouco tempo.

Por que ramificar é importante

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

  • Ter várias equipes trabalhando em um único repositório ao mesmo tempo.
  • Ter membros da equipe em qualquer lugar do mundo usando o Bitbucket Cloud para colaborar.
  • Ter várias linhas de desenvolvimento em execução ao mesmo tempo, independentes umas das outras, sem a necessidade de congelar o 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 é bifurcação?

Bifurcação é outra forma de salvar um clone ou uma cópia. 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.

  1. Acesse tutorials/tutorials.git.bitbucket.org
  2. Clique em + > Bifurcar este repositório no lado esquerdo da tela.
  3. Modifique o Nome para que seja exclusivo da equipe e clique em Bifurcar o repositório.
  4. Crie um diretório para o repositório que seja 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).
  5. Clone o repositório bifurcado no diretório que você acabou de criar. Ele pode se parecer com o seguinte:
     $ 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/
    Que clona o repositório utilizando 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.

  1. Crie um branch usando o comando git branch.
     $ git branch test-1
  2. Verifique o branch que acabou de criar usando o comando git checkout.
     $ git checkout test-1 Switched to branch 'test-1'
  3. Liste os branches que você tem no local usando o comando git branch.
     $ git branch master * test-1
  4. Faça uma atualização no arquivo editme.html adicionando uma cotação. Você pode usar algo assim:
     
    Esta é uma citação, e eu gosto dela.
    Uma citação: a arte de citar
  5. Adicione essa mudança.
     git add editme.html
    Observação: a alteração ainda não passou pelo commit do histórico do Git, mas está em um estado "Aguardando". Aprendemos sobre esse assunto em Salvar alterações.
  6. Faça o commit da alteração com uma mensagem de commit descritiva.
     git commit editme.html -m'adicionou uma nova citação' [test-1 063b772] adicionou uma nova citação 1 arquivo alterado, 3 inserções(+), 3 exclusões(-)
    Observação: agora as alterações fazem parte do histórico do Git como um único "commit". Aprendemos sobre esse assunto em Salvar alterações.
  7. Envie essa alteração para o Bitbucket usando o comando git push.
     git push fatal: A ramificação atual test-1 não tem ramificação upstream. Para enviar a ramificação atual e definir o controle remoto como upstream, use git push --set-upstream origin test-1
    Você vai ver um erro porque, na primeira vez que enviar uma nova ramificação criada no local, é necessário designar essa ramificação.
  8. Envie a ramificação e mude usando o comando git push branch.
     $ git push origin test-1 Contando objetos: 3, pronto. Compressão delta usando até 8 threads. Comprimindo objetos: 100% (3/3), pronto. Gravando objetos: 100% (3/3), 363 bytes | 0 bytes/s, pronto. Total 3 (delta 2), reutilizado 0 (delta 0) remoto: remoto: Criar solicitação pull para test-1: remoto: https://bitbucket.org/dstevenstest/dans.git.bitbucket.org/pull-requests/new?source=test-1&t=1 remoto: Para https://bitbucket.org/dstevenstest/dans.git.bitbucket.org.git * [novo branch] test-1 -> test-1
    Assim o sistema é informado de que o repositório de origem é o destino desta nova ramificação.
  9. Abra seu repositório de tutoriais e clique em Branches. Agora você deve ver o branch principal e a ramificação test-1. Você deve ver algo assim:
Conheça os branches do Bitbucket

Crie, capture e verifique um branch remoto

Ao trabalhar em uma equipe, é possível que você tenha que enviar pulls ou buscar branches que outros membros da equipe criam e fazem push no Bitbucket. Este exemplo vai dar a você algumas noções básicas para criar e trabalhar com os branches criados por eles.

  1. RamificaçõesAcesse o repositório de tutoriais no Bitbucket e clique em Branches. Você deve ver algo assim: Branches
  2. Clique em Criar ramificação, nomeie a ramificação test-2 e clique em Criar.
  3. Copie o comando git fetch na janela verificar branch. É provável que ele seja parecido com o seguinte:
     $ 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'
  4. Use o comando git branch no terminal. Você deve ver uma lista de branches assim:
     $ git branch master test-1 * test-2
    A ramificação com o asterisco * é a ramificação ativa. É fundamental lembrar dessa informação quando você está trabalhando em qualquer fluxo de trabalho de ramificação.
  5. 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 que ramificação está e que a ramificação está atualizada no momento com sua ramificação remota (origin).
  6. Use o comando de git checkout para mudar o foco de volta para sua outra ramificação. O comando vai ser algo 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 serem lembradas ao trabalhar em ramificações é que você quer ter certeza de que a ramificação na qual está fazendo alterações é a ramificação correta.

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.

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

    Como criamos este repositório bifurcando em um repositório existente, o destino é definido como o branch principal do repositório que bifurcamos.

    Para fazer a correção, vai ser necessário alterar o branch de destino do repositório (o branch no qual você vai mesclar suas alterações) de tutorials/tutorials.git.bitbucket.org para o seu repositório.

    Solicitação pull

    Você também adiciona revisores à equipe em solicitação pull. Saiba mais sobre solicitações pull

  2. Clique em Criar solicitação pull.
  3. Faça um comentário na solicitação pull selecionando uma linha na comparação (a área que exibe a alteração que você fez no arquivo editme.html ).
  4. Clique em Aprovar na parte superior esquerda da página. É óbvio que, em uma solicitação pull real, você teria revisores fazendo comentários
  5. Clique em Mesclar.
  6. (Opcional) Atualize a Mensagem de commit com mais informações.
  7. Selecione a estratégia de merge (mesclagem) Merge commit entre as duas opções:
    • Merge commit: mantém todos os commits do branch de origem e os 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 ao mesclar o branch de origem no de destino. Essa opção é o mesmo que digitar git merge --squash na linha de comando.
    Saiba mais para informações sobre esses dois tipos de estratégias de merge.
  8. 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 usados 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 branch principal por pull e o mesclar com o test-2?

Serve como exemplo de quando você está trabalhando em um repositório no qual outro membro da equipe está trabalhando. É uma boa ideia enviar pull de vez em quando com as alterações do branch no qual você está trabalhando para evitar conflitos de merge em solicitações pull.

  1. 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 você está na ramificação que acabou de usar para fazer sua alteração e que você não tem nenhuma alteração. Estamos prontos para nos livrar dessa ramificação agora que terminamos esse trabalho.
  2. 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'.
    Reparou na mensagem que diz que o branch foi atualizado? Ela trata apenas do branch local. A gente tem essa informação porque acabou de mesclar uma alteração no branch principal e não fez envio de pull dessa alteração do repositório remoto para o sistema local. Esse é o próximo passo.
  3. 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 foi o seguinte: quando você envia o pull das alterações do repositório remoto, o git executa um merge de avanço rápido para integrar as alterações que você fez. Ele também lista quantos arquivos e linhas nesse arquivo foram alterados.
  4. Execute o comando git branch -d {branch_name} para remover o branch test-1. O resultado vai ser algo assim:
     $ git branch -d test-1 Deleted branch test-1 (was 063b772)
    Você pode ver que assim o branch foi excluído 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 ele tiver alterações não confirmadas. No entanto, você deve estar ciente de que dessa forma 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.
  5. Mude para o branch test-2 usando o comando git checkout.
     $ git checkout test-2 Switched to branch 'test-2' Your branch is up-to-date with 'origin/test-2'.
  6. Mescle o branch principal e o branch no qual você está trabalhando 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 com o test-2, é necessário que o test-2 seja verificado (ativo). A mesma coisa acontece quando você quer mesclar o test-2 com o branch principal: é preciso verificar o branch principal.
    • Para ver qual branch está ativo a qualquer momento, use o git branch e o branch ativo vai ter um asterisco, ou use git status e ele vai informar em qual 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 você 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 novo branch

Use um branch separado para cada recurso ou problema em que você trabalha. Depois de criar um branch, verifique-o no local para que todas as alterações que você fizer sejam nesse branch.

Atualizar, adicionar, fazer o commit enviar por push as alterações

Trabalhe no recurso e faça commits como faria sempre que usa o Git. Quando estiver pronto, envie os commits, atualizando o branch de recursos no Bitbucket.

Faça uma revisão do seu código

Para obter um retorno sobre seu código, crie uma solicitação pull no Bitbucket. A partir daí, você pode adicionar revisores e garantir que tudo esteja correto antes de mesclar.

Resolver Feedback

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

Mescle o seu branch

Antes de mesclar, talvez seja necessário resolver conflitos de mesclagem se outras pessoas fizerem alterações no repositório. Quando a solicitação pull é aprovada e não tem conflitos, você pode adicionar código ao branch principal. Mesclar a partir da solicitação pull no Bitbucket.

Este tutorial tem por objetivo 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.