Como mesclar a ramificação atual em outra ramificação

Eu tenho dois ramos, mestre e desenvolvedor. Eu sempre trabalho no dev e só verifico o código no ramo mestre depois que ele é aprovado para uso em produção. Quando faço isso, tenho que fazer o seguinte:

git checkout master
git merge dev
git checkout dev

Isso é muito detalhado e, como faço isso com frequência, gostaria de minimizá-lo. Existe algum comando git que eu possa usar para mesclar do meu dev de ramificação atual para o outro mestre de ramificação sem precisar fazer check-out da ramificação mestre primeiro? Algo como:

git merge dev to master

seria fantástico. Examinei a documentação do git e não vi nada.

1. Adicione um alias remoto ao seu repositório local, por exemplo:

git remote add self file:///path/to/your/repository

(Ou no Windows git remote add self C:\path\to\your\repository)

2. Pressione para o controle remoto, ex:

git push self dev:master

A atual resposta mais votada por @zerome é boa, mas é um pouco desnecessária.

Na base do seu repositório git, você pode fazer o seguinte: git push . dev:master

Uma solução mais generalizada que funcionaria em qualquer lugar da árvore seria:

git push $(git rev-parse --show-toplevel) dev:master

Sua melhor aposta seria usar apenas um alias, colocado no seu gitconfig global ( ~/.gitconfig):

[alias]
    merge-to = "!f() { git checkout $1 && git merge $2 && git checkout -; }; f"

para que você possa invocá-lo de qualquer repositório como

git merge-to master dev

Uma pequena modificação do alias do Jefromi que não exige que você digite o ramo atual.

Então você usá-lo como: git merge-to dev.

Isso mudará para o devramo, mesclará com CURRENT e depois retornará.

Por exemplo, supondo que você esteja no masterramo, ele mesclará o mestre no dev e você ainda estará no mestre.

Definitivamente vai para os meus dotfiles :)

[alias]
  merge-to = "!gitmergeto() { export tmp_branch=`git branch | grep '* ' | tr -d '* '` && git checkout $1 && git merge $tmp_branch && git checkout $tmp_branch; unset tmp_branch; }; gitmergeto"

Isso é velho, mas ...

Combinando as soluções de @ kevin-lyda e @ dmytrii-nagirniak acima. esse alias mescla a ramificação atual na ramificação especificada. Ele usa o método remotes com e usa comandos git para obter o contexto.

[alias]
    merge-to = "!gitmergeto() { git push \"`git rev-parse --show-toplevel`\" `git rev-parse --abbrev-ref HEAD`:$1; } && gitmergeto"

Para ser usado como:

git merge-to other-branch-name

Para mesclar a ramificação atual em outra ramificação sem fazer check-out da outra ramificação:

Mesclagem de avanço rápido

Isso é realmente fácil. Por definição, uma mesclagem de avanço rápido significa simplesmente que o ponteiro da ramificação é movido adiante na árvore de confirmação. Então, tudo que você precisa fazer é simular isso:

git branch -f master dev

Advertências: Isso pressupõe que masteraponte para um commit que também esteja no devbranch ou em algum outro branch. Caso contrário, você corre o risco de perder o trabalho! Diferente do git mergeque criará uma confirmação de mesclagem (ou reclamação) quando o avanço rápido não for possível, esse método força silenciosamente o ponteiro da ramificação a apontar para outra confirmação.

Isso também pressupõe que você é o único que trabalha no repositório e / ou sabe o que está fazendo.

Dica: Se você fez um git fetche tem novas confirmações origin/master, pode mover a masterramificação sem fazer check-out usando:

git branch -f master origin/master

Mesclar via consolidação de mesclagem

Isto nem sempre é possível. Para criar uma consolidação de mesclagem, você deve executar uma operação de mesclagem. E para fazer uma operação de mesclagem, você deve ter confirmações na outra ramificação que não está na ramificação atual.

Se você possui confirmações na masterramificação que não estão na devramificação, é possível:

Isenção de responsabilidade: isso é apenas uma prova de conceito, apenas para mostrar que às vezes é possível fazer uma mesclagem com a outra ramificação sem fazer check-out. Se você quiser usá-lo todos os dias, provavelmente deseja criar um alias usando redirecionamento de shell ou criar um script de shell para ele. Então, novamente, você também pode criar um script de shell para o processo mais curto mostrado na pergunta.

git checkout -b temp
git merge --no-ff -e master
git branch -f master temp
git checkout dev
git branch -D temp

Explicação:

1. Confira uma ramificação temporária que aponta para a mesma confirmação que a ramificação atual.

2. Entre masterna ramificação temporária e inicie o editor de mensagens de confirmação. Se você deseja que o commit de mesclagem pareça ter mesclado o devramo master, edite-o a partir deste:

   Merge branch 'master' into temp
   

   para isso:

   Merge branch 'dev'
   

   Dica: você pode usar em -m "Merge branch 'dev'"vez de -eser mais rápido.

3. Atualize o masterponteiro da ramificação para apontar para a consolidação de mesclagem.
4. Confira o devramo.
5. Forçar exclusão da ramificação temporária.

Isso ainda toca sua árvore de trabalho, mas minimamente. Ele não reverte a árvore até o estado original, masterapenas para trazer as mudanças de desenvolvimento mais uma vez. Alguns podem não se importar, mas para outros, pode ser importante.

Muitas vezes você vem do ramo em que gostaria de mesclar o ramo atual. Nesse caso, você poderia fazer:

git co - && git merge @{-1}

por exemplo:

git checkout somebranch      // (while on master)

// add some commits

git co - && git merge @{-1}  // will merge somebranch into master

Minha solução é semelhante às outras respostas, com as seguintes diferenças:

• a função é dividida em várias linhas para facilitar a leitura
• a função chama set -expara que cada comando seja impresso e, se o comando falhar, a função sai imediatamente
• alias passa seus argumentos, exceto o primeiro (ramo de destino) para git merge
• a função inclui um comando nulo : git mergeque garante que a conclusão da guia funcione com algumas configurações do shell (por exemplo, gitfastde oh-my-zsh)

[alias]
  merge-to = "!f() { : git merge ; \
      set -ex ; \
      local this=$(git rev-parse --abbrev-ref HEAD) ; \
      local target=$1 ; \
      shift ; \
      git checkout $target ; \
      git merge $this \"$@\" ; \
      git checkout $this ; \
    } ; f"