Git pull resulta em mensagens estranhas "Merge branch" no log de commit

Estou trabalhando com outro desenvolvedor em um projeto e estamos usando o Github como nosso repositório remoto. Estou em um Mac usando git 1.7.7.3, ele está no Windows usando git 1.7.6.

É isso que está acontecendo

1. Um de nós (vamos chamá-lo de desenvolvedor A, mas não importa qual) envia um conjunto de commits para o GitHub.
2. O outro (desenvolvedor B) faz alguns commits locais.
3. B faz a git pull.
4. B faz a git push.
5. Olhando para o log de histórico de commits , vejo Merge branch 'master' de github.com:foo/bar

O log de commits fica cheio de mensagens "Merge branch" ao longo do tempo e também mostra o desenvolvedor B como as alterações de commit que o desenvolvedor A fez. A única maneira que encontramos de evitar esse problema foi fazer um git pull --rebasena etapa 3, mas não sei quais efeitos colaterais o rebaseing apresentará. Esta é minha primeira vez trabalhando em um repositório git multi-desenvolvedor, então isso é apenas um comportamento normal? Alguma ideia de como resolver esse problema?

O commit que você está vendo está perfeitamente bem. Um pullé executado com eficácia git fetche, git mergegeralmente, ocorre uma fusão quando você executa git pull.

A alternativa de usar rebase em vez de mesclar é possível, mas geralmente você deve evitá-la. Rebasing permite que você mantenha um histórico linear, mas também remove qualquer informação sobre a ramificação que ocorreu originalmente. Isso também fará com que o histórico do branch atual seja reescrito, recriando todos os commits que não estão contidos no branch de destino (no seu caso, o remoto). Como os commits recriados são commits diferentes , isso pode causar muita confusão ao desenvolver junto com outros, especialmente quando as pessoas já deram check-out de partes desses commits antes de serem reescritos (por exemplo, com branches de recursos). Portanto, como regra geral, você nunca deve reescrever nenhum commit que já foi enviado.

Os commits que você vê existem para combinar dois (ou mais) branches. É perfeitamente normal ter um commit que não faz nada mais do que mesclar vários branches. Na verdade, fica muito claro quando você tem um commit de mesclagem que combina ramos ao olhar para o histórico. Em comparação com o rebase, a mesclagem também permite que você veja efetivamente o histórico original conforme foi desenvolvido, incluindo as ramificações reais que coexistiram.

Então, encurtando a história: Sim, ter commits de mesclagem é perfeitamente normal e você não deve se preocupar com eles.

Essa resposta foi revisada, pois meu entendimento, diagramas e conclusões estavam incorretos.

git pullcausa commits de mesclagem porque git está mesclando. Isso pode ser alterado configurando seus branches para usar rebase em vez de merge. Usar rebase em vez de mesclar em um pull fornece um histórico mais linear para o repositório compartilhado. Por outro lado, os commits de mesclagem mostram os esforços de desenvolvimento paralelo no branch.

Por exemplo, duas pessoas estão trabalhando na mesma filial. A filial começa como:

...->C1

A primeira pessoa termina o trabalho e segue para o galho:

...->C1->C2

A segunda pessoa termina o trabalho e quer empurrar, mas não pode porque precisa atualizar. O repositório local para a segunda pessoa se parece com:

...->C1->C3

Se o pull estiver configurado para mesclar, o repositório da segunda pessoa será semelhante a.

...->C1->C3->M1
      \      /
       ->C2->

Onde M1 é um commit de mesclagem. Este novo histórico de branch será enviado ao repositório. Se, em vez disso, o pull for definido para realocar o repositório local terá a seguinte aparência:

...->C1->C2->C3

Não há commit de mesclagem. A história se tornou mais linear.

Ambas as opções refletem a história do ramo. git permite que você escolha o histórico de sua preferência.

De fato, existem lugares onde o rebase pode causar um problema com branches remotos. Este não é um desses casos. Preferimos usar rebase, pois simplifica um histórico de branch já complicado e também mostra uma versão do histórico em relação ao repositório compartilhado.

Você pode definir branch.autosetuprebase = sempre para que o git estabeleça automaticamente seus branches remotos como rebase em vez de master.

git config --global branch.autosetuprebase always

Essa configuração faz com que o git crie automaticamente uma definição de configuração para cada branch remoto:

branch.<branchname>.rebase=true

Você mesmo pode definir isso para suas filiais remotas que já estão configuradas.

git config branch.<branchname>.rebase true

Gostaria de agradecer a @LaurensHolst por questionar e buscar minhas declarações anteriores. Eu certamente aprendi mais sobre como o git funciona com pull e merge commits.

Para obter mais informações sobre commits de mesclagem, você pode ler Contribuindo para um projeto no ProGit-Book . A seção Private Small Team mostra os commits de mesclagem.

Você pode fazer:

git pull --rebase

No entanto, isso sempre colocará suas alterações em cima das de seus colaboradores. Mas você não receberá nenhuma mensagem de mesclagem poluente.

Na verdade, há uma resposta muito mais simples para isso. Apenas faça com que o desenvolvedor B faça um pull ANTES de fazer seu commit. Isso impedirá os commits de mesclagem, já que eles são causados ​​pelo histórico que você criou em seu repositório local a partir de seu commit local tentando mesclar com o histórico dos commits no repo remoto. Se você receber uma mensagem dizendo algo parecido com 'as alterações serão sobrescritas' ao fazer um pull, significa apenas que vocês tocaram no mesmo arquivo, então faça:

git stash
git pull
git stash pop

então você pode resolver quaisquer conflitos de mesclagem, se houver.

Fazer um git pull irá inserir as mensagens "Merge branch", é exatamente o que faz. Ao fazer um git pull, você fundiu o branch remoto em seu branch local.

Quando você faz um git pull e há conflitos, o log do git mostrará as atualizações dos arquivos em conflito como provenientes do usuário que resolveu os conflitos. Presumo que seja porque a pessoa que corrige o conflito compromete novamente o arquivo.

Pelo que eu sei, é assim que o git funciona, e não há uma maneira de contornar isso.

Rebasing vai acabar com o histórico do git, então você não será capaz de ver quando as fusões ocorreram.