git pull do master para o ramo de desenvolvimento

496

Eu tenho um ramo chamado dmgr2 (desenvolvimento) e quero extrair do ramo mestre (site ativo) e incorporar todas as alterações no meu ramo de desenvolvimento. Existe uma maneira melhor de fazer isso? Aqui está o que eu planejava fazer, depois de fazer alterações:

git checkout dmgr2
git pull origin master

isso deve puxar as alterações dinâmicas para o meu ramo de desenvolvimento, ou eu entendi errado?

git branch pull Matthew Colley
fonte
1
primeiro confirme todas as suas alterações no ramo dmgr2. e aponte para mestre 1.git checkout master e obtenha as alterações mais recentes 2.git pull 3.git merge dmgr2 4.git push -u origin master E, em seguida, volte para o dmgr2 5.git checkout dmgr2
mat_vee
i já se comprometeram todas as minhas alterações no ramo dmgr2, não esqueceu de acrescentar que
Matthew Colley
1
se eu executar a etapa 4, isso não empurrará meu desenvolvimento para o master? Eu não quero fazer isso
Matthew Colley
Então, o que você está dizendo é que deseja trazer as alterações do seu ramo principal para o seu ramo de desenvolvimento?
JcKelley
9
Alterne para devramificar com a git checkout dev. Então git pull --rebase origin master. Se você tiver sorte, não haverá conflitos e o dev terá as alterações mais recentes do master.
JWW

Respostas:

725

As etapas listadas funcionarão, mas há uma maneira mais longa de oferecer mais opções:

git checkout dmgr2      # gets you "on branch dmgr2"
git fetch origin        # gets you up to date with origin
git merge origin/master

O fetchcomando pode ser feito a qualquer momento antes de merge, ou seja, você pode trocar a ordem da busca e do checkout, porque fetchapenas passa para o remote ( origin) e diz: "me dê tudo o que você tem ", ou seja, tudo confirma em todos os ramos. Eles são copiados para o seu repositório, mas com o nome origin/branchde qualquer filial nomeada branchno controle remoto.

Nesse ponto, você pode usar qualquer visualizador ( git log, gitketc) para ver "o que eles têm" que você não possui e vice-versa. Às vezes, isso é útil apenas para Warm Fuzzy Feelings ("ah, sim, é de fato o que eu quero") e, às vezes, é útil para mudar completamente as estratégias ("whoa, eu não quero isso ainda").

Finalmente, o mergecomando leva o commit fornecido, que você pode nomear como origin/master, e faz o que for necessário para trazer esse commit e seus ancestrais, para qualquer ramo em que você esteja quando executar o merge. Você pode inserir --no-ffou --ff-onlyimpedir um avanço rápido ou mesclar apenas se o resultado for um avanço rápido, se desejar.

Quando você usa a sequência:

git checkout dmgr2
git pull origin master

o pullcomando instrui o git a executar git fetche, em seguida, o equivalente moral de git merge origin/master. Portanto, isso é quase o mesmo que executar as duas etapas manualmente, mas existem algumas diferenças sutis que provavelmente não são muito importantes para você. (Em particular, a fetchetapa executada pulltraz apenas a substituição origin/mastere ela não atualiza a ref no seu repo: 1 qualquer novo commit acaba sendo referido apenas pela FETCH_HEADreferência especial .)

Se você usar a sequência mais explícita git fetch origin(em seguida, opcionalmente, procurar) e, em seguida git merge origin/master, também poderá atualizar seu próprio local mastercom o controle remoto, com apenas uma fetchexecução na rede:

git fetch origin
git checkout master
git merge --ff-only origin/master
git checkout dmgr2
git merge --no-ff origin/master

por exemplo.

1 Esta segunda parte foi alterada - digo "corrigida" - no git 1.8.4, que agora atualiza referências de "ramificação remota" oportunamente. (Foi, como dizem as notas de versão, uma decisão deliberada do projeto de ignorar a atualização, mas acontece que mais pessoas preferem que o git atualize. e, portanto, recuperável a partir do reflog, o que também permite um novo recurso git 1.9 / 2.0 para encontrar rebotes upstream.)

torek
fonte
28
Só estou pedindo um amigo - como você desfaz o primeiro bloco de código que você tem aqui (checkout / busca / mesclagem)?
Rich Bradshaw
10
@ RichBradshaw: git checkoutnormalmente não é destrutivo e normalmente não há motivo para desfazer uma git fetch, por isso parece que você está perguntando como recuperar um commit de mesclagem. A resposta é a mesma que para outras confirmações: ou git resetou git revert. Para alterações não publicadasgit reset é geralmente o melhor método; para mudanças que outras pessoas já têm, git revertpode ser melhor, mas consulte o conselho de Linus Torvald sobre a reversão de uma mesclagem: kernel.org/pub/software/scm/git/docs/howto/…
torek
2
@WeDoTDD: Não entendi a pergunta. Existem vários comandos para exibir o gráfico de confirmação ( gitk, git log --graphcom ou sem --onelinee assim por diante) e você pode git showou pode git show -mconfirmar ou usar uma mesclagem git diff. Em todos esses casos, você está especificando o programa ao inserir o comando na linha de comando.
precisa saber é
1
@torek: tentei o seu caminho de: git checkout branch e, em seguida, git pull origin master, mas puxou todas as alterações principais como uma única alteração que deve ser confirmada localmente novamente, em vez de puxá-las com o histórico e as mensagens de confirmação, portanto, depois de atualizar o local mestre e alternando para ramificação, "git rebase master" faz o trabalho com todos os conflitos a serem resolvidos e, em seguida, adiciono a "git pull --rebase" e lida novamente com todos os conflitos e, em seguida, git push origin branch para alinhar tudo. Eu acho que deveria haver uma maneira melhor para isso - estou certo?
user10556443
1
@torek: Eu concordo que o resultado obtido é um processo cansativo que me obriga a repetir rebase e mesclagem e ... toda vez que eu quero receber uma atualização do mestre ... Mas, a maneira proposta, que eu admito é muito mais fácil, obteve todas as alterações sob uma única alteração não confirmada na filial local, sem manter o pedido / histórico de confirmação mestre. Eu vou ser feliz ao saber da sugestão melhor como usar o "esforço" e manter o controle de mestre sem a necessidade de usar "puxar" etc.
user10556443
14

Situação : trabalhando em minha filial local, mas gosto de manter as atualizações na ramificação de desenvolvimento denominada dev.

Solução : Normalmente, prefiro fazer:

git fetch
git rebase origin/dev
greenridinghood
fonte
15
Com o aviso de isenção habitual de que a reformulação só deve ser feita se a ramificação local for apenas local, ou seja, não tiver sido enviada a lugar algum, pois ele reescreve o histórico.
Locus
8

Isso funcionou para mim. Para obter o código mais recente do master para o meu ramo

git rebase origin/master

Pratik Gaurav
fonte
Não se esqueça de git fetch originprimeiro.
lenooh
3

Cenário :

Tenho atualização mestre e minha filial atualizando, quero que minha filial acompanhe o mestre com rebasing, mantenha todo o histórico rastreado corretamente, vamos chamar minha filial Mybranch

Solução :

git checkout master    
git pull --rebase    
git checkout Mybranch    
git rebase master
git push -f origin Mybranch
  • precisa resolver todos os conflitos com o git mergetool &, git rebase --continue, git rebase --skip, git add -u, de acordo com a situação e as dicas do git, até que tudo esteja resolvido

(correção para o último estágio, cortesia de Tzachi Cohen, usar "-f" força o git a "atualizar o histórico" no servidor)

agora o ramo deve estar alinhado com o mestre e reformulado, também com atualização remota, portanto, no log do git, não há "behind" ou "ahead", basta remover todos os arquivos * .orig de conflito local para manter a pasta "limpa"

user10556443
fonte