Comment savoir si une branche a déjà été fusionnée en master?

J'ai un référentiel git avec plusieurs branches.

Comment savoir quelles branches sont déjà fusionnées dans la branche principale?

git branch --merged masterrépertorie les branches fusionnées en maître

git branch --mergedrépertorie les branches fusionnées dans HEAD (c'est-à-dire la pointe de la branche actuelle)

git branch --no-merged répertorie les branches qui n'ont pas été fusionnées

Par défaut, cela s'applique uniquement aux succursales locales. Le -adrapeau affichera les branches locales et distantes, et le -rdrapeau ne montrera que les branches distantes.

Vous pouvez utiliser la git merge-basecommande pour trouver le dernier commit commun entre les deux branches. Si ce commit est le même que votre chef de branche, alors la branche a été complètement fusionnée.

Notez que git branch -dcela fait déjà ce genre de choses car il refusera de supprimer une branche qui n'a pas encore été complètement fusionnée.

Il existe également une solution d'interface graphique. Tapez simplement

gitk --all

Une nouvelle fenêtre d'application vous demandera une représentation graphique de l'ensemble de votre référentiel, où il est très facile de savoir si une branche a déjà été fusionnée ou non

J'utilise la fonction bash suivante comme: 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
}

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

Cette commande trouve les meilleurs ancêtres communs entre deux commits. Et si l'ancêtre commun est identique au dernier commit d'une "branche", alors nous pouvons sans risque supposer qu'une "branche" a déjà été fusionnée dans le maître.

Voici les étapes

1. Trouver le dernier hachage de validation sur la branche principale
2. Trouver le dernier hachage de validation sur une "branche"
3. Exécuter la commande git merge-base <commit-hash-step1> <commit-hash-step2>.
4. Si la sortie de l'étape 3 est identique à la sortie de l'étape 2, alors une "branche" a déjà été fusionnée en maître.

Plus d'informations sur git merge-base https://git-scm.com/docs/git-merge-base .

Sur le thème du nettoyage des succursales distantes

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

Ceci répertorie chaque branche distante suivie par les branches distantes dans lesquelles se trouvent leurs derniers SHA.

Ceci est utile pour discerner quelles branches distantes ont été fusionnées mais pas supprimées, et lesquelles n'ont pas été fusionnées et sont donc en décomposition.

Si vous utilisez 'tig' (c'est comme gitk mais basé sur un terminal), vous pouvez

tig origin/feature/someones-decaying-feature

pour voir l'historique des validations d'une branche sans avoir à passer à la caisse

Afin de vérifier quelles branches sont fusionnées en master, vous devez utiliser ces commandes:

• git branch <flag[-r/-a/none]> --merged master liste de toutes les branches fusionnées en master.
• git branch <flag[-r/-a/none]> --merged master | wc -l compter le nombre de toutes les branches fusionnées en maître.

Les drapeaux sont:

• -adrapeau - (tous) montrant les succursales éloignées et locales
• -rdrapeau - (distant) affichant uniquement les branches distantes
• <emptyFlag>- montrant uniquement les succursales locales

par exemple: git branch -r --merged master vous montrera tous les référentiels distants fusionnés dans master.

Voici mes techniques lorsque j'ai besoin de déterminer si une branche a été fusionnée, même si elle a peut-être été rebasée pour être à jour avec notre branche principale, ce qui est un scénario courant pour les branches de fonctionnalités.

Aucune de ces approches n'est infaillible, mais je les ai trouvées utiles à plusieurs reprises.

1 Afficher le journal pour toutes les branches

En utilisant un outil visuel comme gitk ou TortoiseGit, ou simplement git log avec --all, parcourez l'historique pour voir toutes les fusions vers la branche principale. Vous devriez pouvoir repérer si cette branche de fonctionnalité particulière a été fusionnée ou non.

2 Toujours supprimer la branche distante lors de la fusion dans une branche de fonction

Si vous avez l'habitude de toujours supprimer la branche locale et la branche distante lorsque vous fusionnez dans une branche de fonctionnalité, vous pouvez simplement mettre à jour et tailler les télécommandes sur votre autre ordinateur et les branches de fonctionnalité disparaîtront.

Pour ne pas oublier de le faire, j'utilise déjà des extensions de flux git (édition AVH) pour créer et fusionner mes branches de fonctionnalités localement, j'ai donc ajouté le hook de flux git suivant pour me demander si je souhaite également supprimer automatiquement la branche distante.

Exemple de branche de fonction de création / finition

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 / hooks / post-flow-feature-finish

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 Recherche par message de validation

Si vous ne supprimez pas toujours la branche distante, vous pouvez toujours rechercher des validations similaires pour déterminer si la branche a été fusionnée ou non. Le piège ici est que la branche distante a été redéfinie sur le non reconnaissable, comme écraser les commits ou changer les messages de commit.

• Récupérer et tailler toutes les télécommandes
• Rechercher le message du dernier commit sur la branche de fonctionnalité
• Voir si une validation avec le même message peut être trouvée sur la branche principale

Exemples de commandes sur la branche principale:

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

Dans ma configuration bash .profile

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

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

Voici un petit one-liner qui vous permettra de savoir si votre branche actuelle incorpore ou est à court de données d'une branche d'origine / maître distante:

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

Je suis tombé sur cette question lorsque je travaillais sur une branche de fonctionnalité et que je voulais souvent m'assurer que le travail le plus récent était intégré dans ma propre branche de travail distincte.

Pour généraliser ce test, j'ai ajouté l'alias suivant à mon ~ / .gitconfig:

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

Ensuite, je peux appeler:

$ git current origin/master

pour vérifier si je suis à jour.