Como posso saber no git se uma ramificação já foi mesclada em master?



git tutorial (7)

Eu tenho um repositório git com vários ramos.

Como posso saber quais ramificações já estão mescladas na ramificação principal?


git branch --merged master listas ramos mesclados em mestre

git branch --merged listas git branch --merged mescladas em HEAD (ou seja, ponta da ramificação atual)

git branch --no-merged ramificações que não foram mescladas

Por padrão, isso se aplica apenas aos ramos locais. O sinalizador -a mostrará as ramificações locais e remotas, e o sinalizador -r mostra apenas as ramificações remotas.


Eu estou usando a seguinte função bash como: git-is-merged develop feature/new-feature

git-is-merged () {
  merge_destination_branch=$1
  merge_source_branch=$2

  merge_base=$(git merge-base $merge_destination_branch $merge_source_branch)
  merge_source_current_commit=$(git rev-parse $merge_source_branch)
  if [[ $merge_base = $merge_source_current_commit ]]
  then
    echo $merge_source_branch is merged into $merge_destination_branch
    return 0
  else
    echo $merge_source_branch is not merged into $merge_destination_branch
    return 1
  fi
}

Aqui está um pequeno one-liner que informará se sua filial atual incorpora ou está sem dados de uma origem / ramificação principal remota:

$ git fetch && git branch -r --merged | grep -q origin/master && echo Incorporates origin/master || echo Out of date from origin/master

Eu me deparei com essa pergunta quando estou trabalhando em um ramo de recursos e freqüentemente querendo ter certeza de que eu tenho o trabalho mais recente incorporado em meu próprio ramo de trabalho separado.

Para generalizar este teste, adicionei o seguinte alias ao meu ~ / .gitconfig:

[alias]
   current = !git branch -r --merged | grep -q $1 && echo Incorporates $1 || echo Out of date from $1 && :

Então eu posso ligar:

$ git current origin/master

para verificar se estou atual.


Aqui estão minhas técnicas quando preciso descobrir se uma ramificação foi mesclada, mesmo que possa ter sido reformulada para estar atualizada com nossa ramificação principal, que é um cenário comum para ramificações de recursos.

Nenhuma dessas abordagens é à prova de erros, mas eu as achei úteis muitas vezes.

1 Mostrar registro para todas as filiais

Usando uma ferramenta visual como gitk ou TortoiseGit, ou simplesmente git log com --all, percorra o histórico para ver todas as mesclagens para o ramo principal. Você deve ser capaz de identificar se essa ramificação de recurso específica foi mesclada ou não.

2 Sempre remover ramo remoto ao mesclar em um ramo de recurso

Se você tiver um bom hábito de sempre remover a ramificação local e remota ao mesclar em uma ramificação de recurso, poderá simplesmente atualizar e remover os remotos em outro computador e as ramificações de recurso desaparecerão.

Para ajudar a lembrar disso, já estou usando as extensões de fluxo do git (edição AVH) para criar e mesclar minhas ramificações de recurso localmente, então adicionei o gancho de fluxo git a seguir para perguntar se eu também quero remover automaticamente a ramificação remota.

Exemplo de criação / finalização do ramo de funcionalidades

554 Andreas:MyRepo(develop)$ git flow start tmp
Switched to a new branch 'feature/tmp'

Summary of actions:
- A new branch 'feature/tmp' was created, based on 'develop'
- You are now on branch 'feature/tmp'

Now, start committing on your feature. When done, use:

     git flow feature finish tmp

555 Andreas:MyRepo(feature/tmp)$ git flow finish
Switched to branch 'develop'
Your branch is up-to-date with 'if/develop'.
Already up-to-date.

[post-flow-feature-finish] Delete remote branch? (Y/n)
Deleting remote branch: origin/feature/tmp.

Deleted branch feature/tmp (was 02a3356).

Summary of actions:
- The feature branch 'feature/tmp' was merged into 'develop'
- Feature branch 'feature/tmp' has been locally deleted
- You are now on branch 'develop'

556 Andreas:ScDesktop (develop)$

.git / ganchos / pós-fluxo-recurso-acabamento

NAME=$1
ORIGIN=$2
BRANCH=$3

# Delete remote branch
# Allows us to read user input below, assigns stdin to keyboard
exec < /dev/tty

while true; do
  read -p "[post-flow-feature-finish] Delete remote branch? (Y/n) " yn
  if [ "$yn" = "" ]; then
    yn='Y'    
  fi
  case $yn in
      [Yy] ) 
        echo -e "\e[31mDeleting remote branch: $2/$3.\e[0m" || exit "$?"
        git push $2 :$3; 
        break;;
      [Nn] ) 
        echo -e "\e[32mKeeping remote branch.\e[0m" || exit "$?"
        break;;
      * ) echo "Please answer y or n for yes or no.";;
  esac
done

# Stop reading user input (close STDIN)
exec <&-
exit 0

3 Pesquisar por mensagem de confirmação

Se você nem sempre remover a ramificação remota, ainda poderá procurar confirmações semelhantes para determinar se a ramificação foi mesclada ou não. A armadilha aqui é se a ramificação remota foi rebaixada para o irreconhecível, como commits de esmagamento ou alteração de mensagens de confirmação.

  • Buscar e podar todos os controles remotos
  • Localizar mensagem do último commit no ramo de recursos
  • Veja se um commit com a mesma mensagem pode ser encontrado no branch master

Exemplo de comandos no ramo mestre:

gru                   
gls origin/feature/foo
glf "my message"

Na minha configuração bash .profile

alias gru='git remote update -p'
alias glf=findCommitByMessage

findCommitByMessage() {
    git log -i --grep="$1"
}

Sobre o tema da limpeza de filiais remotas

git branch -r | xargs -t -n 1 git branch -r --contains

Isto lista cada ramificação remota seguido por quais ramificações remotas seus últimos SHAs estão dentro.

Isso é útil para discernir quais ramificações remotas foram mescladas, mas não excluídas, e quais não foram mescladas e, portanto, estão decaindo.

Se você está usando 'tig' (é como o gitk, mas baseado em terminal), então você pode

tig origin/feature/someones-decaying-feature

para ver o histórico de commits de um branch sem ter que fazer checkout


Existe também uma solução de interface gráfica. Apenas digite

gitk --all

Uma nova janela do aplicativo será exibida com uma representação gráfica de todo o seu repositório, onde é muito fácil perceber se um branch já foi mesclado ou não


Use git merge-base <commit> <commit> .

Este comando encontra o melhor ancestral comum entre dois commits. E se o ancestral comum é idêntico ao último commit de um "branch", então podemos seguramente assumir que um "branch" já foi mesclado no master.

Aqui estão os passos

  1. Encontre o último commit do hash no branch master
  2. Encontre o último commit do hash em um "branch"
  3. Execute o comando git merge-base <commit-hash-step1> <commit-hash-step2> .
  4. Se a saída da etapa 3 for a mesma da saída da etapa 2, uma "ramificação" já terá sido mesclada no mestre.

Mais informações sobre o git merge-base https://git-scm.com/docs/git-merge-base .





git