Comment vérifier si une branche Git est orpheline

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si une branche Git est orpheline. Nous allons explorer la commande git log pour comprendre les commits sans commits parents, ce qui est caractéristique du commit initial dans un dépôt.

En outre, vous utiliserez la commande git branch --no-merged pour identifier les branches dont les modifications n'ont pas été intégrées dans la branche actuelle. Enfin, vous testerez ces concepts en créant et en examinant une nouvelle branche orpheline.

Skills Graph

Vérifier le journal Git (git log) pour les commits sans parent

Dans cette étape, nous allons explorer plus en détail la commande git log, en particulier son comportement dans un dépôt avec des commits sans parents. C'est le cas du tout premier commit dans un dépôt.

Tout d'abord, assurez-vous d'être dans le répertoire my-time-machine :

cd ~/project/my-time-machine

Maintenant, utilisons la commande git log avec l'option --pretty=oneline. Cette option affiche chaque commit sur une seule ligne, ce qui est utile pour avoir une vue concise de l'historique. Nous allons également ajouter l'option --max-count=1 pour n'afficher que le commit le plus récent.

git log --pretty=oneline --max-count=1

Vous devriez voir une sortie similaire à celle-ci :

a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9 (HEAD -> master) Send a message to the future

Cette sortie montre le hachage du commit (la longue chaîne de caractères), la branche sur laquelle il se trouve (HEAD -> master) et le message de commit.

Maintenant, essayons de voir le parent de ce commit. Comme il s'agit du tout premier commit, il n'a pas de parent. Nous pouvons utiliser l'option --no-walk=parent avec git log pour tenter d'afficher le commit parent.

git log --no-walk=parent --pretty=oneline --max-count=1

Cette commande ne produira probablement aucune sortie, ou un message d'erreur indiquant qu'il n'y a pas de commit parent à afficher. C'est le comportement attendu pour le commit initial.

Comprendre que le premier commit n'a pas de parent est fondamental pour comprendre comment Git construit son historique. Chaque commit subséquent aura un ou plusieurs parents, formant une chaîne de modifications.

Utiliser git branch --no-merged

Dans cette étape, nous allons apprendre à utiliser la commande git branch et plus particulièrement l'option --no-merged. Cette option nous permet d'identifier les branches qui contiennent des modifications qui n'ont pas encore été intégrées dans la branche actuelle.

Tout d'abord, créons une nouvelle branche. Imaginez une branche comme une ligne de temps alternative où vous pouvez travailler sur de nouvelles fonctionnalités ou des expériences sans affecter la ligne de temps principale (master).

Assurez-vous d'être dans le répertoire ~/project/my-time-machine.

cd ~/project/my-time-machine

Maintenant, créons une nouvelle branche appelée experiment :

git branch experiment

Cette commande crée la nouvelle branche, mais ne vous bascule pas sur celle-ci. Vous êtes toujours sur la branche master.

Listons toutes les branches de notre dépôt en utilisant la commande git branch :

git branch

Vous devriez voir une sortie similaire à celle-ci :

  experiment
* master

L'astérisque (*) indique la branche sur laquelle vous vous trouvez actuellement, qui est master.

Maintenant, utilisons la commande git branch --no-merged. Cette commande liste les branches qui n'ont pas été fusionnées dans la branche actuelle (master).

git branch --no-merged

Vous devriez voir :

  experiment

Cette sortie nous indique que la branche experiment contient des modifications qui ne sont pas présentes dans la branche master. Dans ce cas, puisque nous venons de créer la branche experiment à partir de master et que nous n'avons pas encore effectué de modifications sur celle-ci, cela peut sembler contre-intuitif. Cependant, l'option --no-merged est conçue pour afficher les branches dont le commit de pointe n'est pas accessible depuis le pointe de la branche actuelle. Étant donné que experiment pointe actuellement vers le même commit que master, mais que master n'a pas "fusionné" experiment (ce qui n'a pas de sens dans ce contexte), elle liste toujours experiment.

Dans un scénario réel, vous créeriez généralement une nouvelle branche, effectueriez quelques commits sur celle-ci, puis utiliseriez git branch --no-merged depuis votre branche principale (comme master) pour voir quelles branches de fonctionnalités sont prêtes à être fusionnées.

Tester avec une nouvelle branche orpheline

Dans cette étape, nous allons créer une nouvelle branche "orpheline". Une branche orpheline est une branche qui commence sans historique des branches précédentes. C'est comme démarrer une toute nouvelle ligne de temps dans votre machine à remonter le temps. Cela est utile pour des choses telles que les branches de documentation ou les branches gh-pages pour les sites web, où vous ne voulez pas inclure l'historique de votre code principal.

Assurez-vous d'être dans le répertoire ~/project/my-time-machine.

cd ~/project/my-time-machine

Maintenant, créons une nouvelle branche orpheline appelée new-start :

git checkout --orphan new-start

Vous devriez voir une sortie similaire à celle-ci :

Switched to a new branch 'new-start'

Nous sommes maintenant sur la branche new-start. Remarquez que les fichiers de la branche master sont toujours présents dans votre répertoire de travail. C'est parce que git checkout --orphan prépare votre répertoire de travail et l'index pour un nouveau commit racine, mais il ne supprime pas les fichiers existants.

Vérifions l'état :

git status

Vous devriez voir quelque chose comme ceci :

On branch new-start

Untracked files:
  (use "git add <file>..." to include in what will be committed)
        message.txt

nothing added to commit but untracked files present (use "git add" to track)

Git considère message.txt comme un fichier non suivi car l'historique de la branche new-start est complètement séparé de celui de master.

Pour vraiment commencer à neuf sur cette branche orpheline, nous supprimons généralement les anciens fichiers puis ajoutons le nouveau contenu pour cette branche. Supprimons le fichier message.txt :

rm message.txt

Maintenant, vérifions à nouveau l'état :

git status

Vous devriez voir :

On branch new-start

No commits yet

nothing to commit (create/copy files and use "git add" to track)

Le répertoire de travail est maintenant propre, et nous sommes prêts à créer le premier commit sur notre nouvelle ligne de temps indépendante.

Créons un nouveau fichier spécifique à cette branche :

echo "This is a fresh start!" > readme.md

Ajoutons le nouveau fichier à la zone de préparation :

git add readme.md

Et enfin, créons le premier commit sur la branche new-start :

git commit -m "Initial commit for new-start branch"

Vous devriez voir une sortie similaire à celle-ci :

[new-start (root-commit) a1b2c3d] Initial commit for new-start branch
 1 file changed, 1 insertion(+)
 create mode 100644 readme.md

Remarquez que ce commit est également un "(root-commit)", tout comme le premier commit sur la branche master. Cela confirme qu'il n'a pas de parent et qu'il est le début d'un nouvel historique.

Maintenant, regardons le journal pour cette branche :

git log --pretty=oneline

Vous devriez voir seulement le seul commit que nous venons de créer :

a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9 (HEAD -> new-start) Initial commit for new-start branch

Cela démontre que la branche new-start a son propre historique indépendant, séparé de celui de la branche master.

Résumé

Dans ce laboratoire (lab), nous avons appris à vérifier si une branche Git est orpheline. Nous avons commencé par explorer la commande git log, en particulier comment identifier l'absence d'un commit parent pour le premier commit dans un dépôt en utilisant --no-walk=parent. Cela a démontré le concept fondamental de l'historique Git selon lequel le premier commit n'a pas de parent.

Ensuite, nous avons été présentés à la commande git branch --no-merged. Cette commande est utilisée pour lister les branches qui n'ont pas été fusionnées dans la branche actuelle, ce qui est une technique clé pour identifier les branches qui pourraient être orphelines ou contenir des modifications non intégrées. Le laboratoire incluait également une étape pour tester ces concepts en créant et en examinant une nouvelle branche orpheline.