Je voudrais renommer / déplacer un sous-arbre de projet dans Git en le déplaçant de

/project/xyz

à

/components/xyz

Si j'utilise un plain git mv project components, alors tout l'historique des validations pour le xyz projectest perdu. Y a-t-il un moyen de faire bouger cela de telle sorte que l'histoire soit maintenue?

Git détecte les renommages plutôt que de persister l'opération avec la validation, que vous utilisiez git mvou mvnon.

La logcommande prend un --followargument qui continue l'historique avant une opération de renommage, c'est-à-dire qu'elle recherche un contenu similaire en utilisant l'heuristique:

http://git-scm.com/docs/git-log

Pour rechercher l'historique complet, utilisez la commande suivante:

git log --follow ./path/to/file

Il est possible de renommer un fichier et de conserver l'historique intact, bien que cela entraîne le changement de nom du fichier tout au long de l'historique du référentiel. C'est probablement seulement pour les amateurs de git-log obsessionnels, et a de sérieuses implications, y compris celles-ci:

• Vous pourriez réécrire une histoire partagée, ce qui est le plus important à NE PAS FAIRE lorsque vous utilisez Git. Si quelqu'un d'autre a cloné le référentiel, vous le casserez en procédant ainsi. Ils devront recloner pour éviter les maux de tête. Cela pourrait être OK si le changement de nom est suffisamment important, mais vous devrez y réfléchir attentivement - vous pourriez finir par bouleverser toute une communauté opensource!
• Si vous avez référencé le fichier en utilisant son ancien nom plus tôt dans l'historique du référentiel, vous rompez effectivement les versions antérieures. Pour y remédier, vous devrez faire un peu plus de saut de cerceau. Ce n'est pas impossible, juste fastidieux et peut-être pas la peine.

Maintenant, puisque vous êtes toujours avec moi, vous êtes probablement un développeur solo renommant un fichier complètement isolé. Déplaçons un fichier en utilisant filter-tree!

Supposons que vous allez déplacer un fichier olddans un dossier diret donnez-lui le nomnew

Cela pourrait être fait avec git mv old dir/new && git add -u dir/new, mais cela brise l'histoire.

Au lieu:

git filter-branch --tree-filter 'if [ -f old ]; then mkdir dir && mv old dir/new; fi' HEAD

va refaire chaque commit dans la branche, exécutant la commande dans les ticks pour chaque itération. Beaucoup de choses peuvent mal tourner lorsque vous faites cela. Normalement, je teste pour voir si le fichier est présent (sinon il n'est pas encore là pour se déplacer), puis j'effectue les étapes nécessaires pour chausse-pied l'arbre à mon goût. Ici, vous pouvez parcourir les fichiers pour modifier les références au fichier, etc. Assommez-vous! :)

Une fois terminé, le fichier est déplacé et le journal est intact. Vous vous sentez comme un pirate ninja.

Aussi; Le répertoire mkdir n'est nécessaire que si vous déplacez le fichier vers un nouveau dossier, bien sûr. L' if évitera la création de ce dossier plus tôt dans l'historique que votre fichier n'existe.

Non.

La réponse courte est NON . Il n'est pas possible de renommer un fichier dans Git et de se souvenir de l'historique. Et c'est une douleur.

La rumeur veut que git log --follow--find-copies-hardercela fonctionne, mais cela ne fonctionne pas pour moi, même s'il n'y a aucun changement dans le contenu du fichier et que les déplacements ont été effectués avecgit mv .

(Initialement, j'ai utilisé Eclipse pour renommer et mettre à jour des packages en une seule opération, ce qui peut avoir gêné Git. Mais c'est une chose très courante à faire. --followSemble fonctionner si seulement un mvest effectué, puis un commitet le mvn'est pas trop loin.)

Linus dit que vous êtes censé comprendre l'ensemble du contenu d'un projet logiciel de manière holistique, sans avoir besoin de suivre les fichiers individuels. Eh bien, malheureusement, mon petit cerveau ne peut pas faire ça.

C'est vraiment ennuyeux que tant de gens aient répété sans réfléchir la déclaration selon laquelle Git suit automatiquement les mouvements. Ils ont perdu mon temps. Git ne fait rien de tel. De par sa conception (!) Git ne suit pas du tout les mouvements.

Ma solution consiste à renommer les fichiers à leur emplacement d'origine. Modifiez le logiciel pour l'adapter au contrôle de source. Avec Git, vous semblez juste avoir besoin de "git" correctement la première fois.

Malheureusement, cela casse Eclipse, qui semble utiliser --follow. git log --followparfois, n'affiche pas l'historique complet des fichiers avec des historiques de changement de nom compliqués, même s'il le git logfait. (Je ne sais pas pourquoi.)

(Il y a des hacks trop intelligents qui reviennent en arrière et recommencent du vieux travail, mais ils sont plutôt effrayants. Voir GitHub-Gist: emiller / git-mv-with-history .)

git log --follow [file]

vous montrera l'historique à travers les renommage.

Je fais:

git mv {old} {new}
git add -u {new}

Je voudrais renommer / déplacer un sous-arbre de projet dans Git en le déplaçant de

/project/xyz

à

/ composants / xyz

Si j'utilise un plain git mv project components, alors tout l'historique de validation du xyzprojet est perdu.

Non (8 ans plus tard, Git 2.19, Q3 2018), car Git détectera le renommage du répertoire , et cela est désormais mieux documenté.

Voir commit b00bf1c , commit 1634688 , commit 0661e49 , commit 4d34dff , commit 983f464 , commit c840e1a , commit 9929430 (27 juin 2018) et commit d4e8062 , commit 5dacd4a (25 juin 2018) par Elijah Newren ( newren) .
^{(Fusionné par Junio ​​C Hamano - gitster- en commit 0ce5a69 , 24 juil.2018 )}

Cela est maintenant expliqué dans Documentation/technical/directory-rename-detection.txt:

Exemple:

Lorsque tous x/a, x/bet x/cont été déplacés vers z/a, z/bet z/c, il est probable que x/dajouté entre-temps souhaiterait également passer à z/den supposant que le répertoire entier ' x' a été déplacé ' z'.

Mais ce sont bien d'autres cas, comme:

un côté de l'historique renomme x -> zet l'autre renomme un fichier x/e, ce qui oblige la fusion à effectuer un changement de nom transitif.

Pour simplifier la détection de renommage de répertoire, ces règles sont appliquées par Git:

une couple de règles de base limite lorsque la détection de renommage de répertoire s'applique:

1. Si un répertoire donné existe toujours des deux côtés d'une fusion, nous ne le considérons pas comme ayant été renommé.
2. Si un sous-ensemble de fichiers à renommer contient un fichier ou un répertoire (ou serait le même), "désactivez" le répertoire renommé pour ces sous-chemins spécifiques et signalez le conflit à l'utilisateur .
3. Si l'autre côté de l'historique a renommé un répertoire en un chemin que votre côté de l'historique a renommé, ignorez ce renommage particulier de l'autre côté de l'historique pour tout renommage de répertoire implicite (mais avertissez l'utilisateur).

Vous pouvez voir de nombreux tests dans t/t6043-merge-rename-directories.sh, qui soulignent également que:

• a) Si les renommages divisent un répertoire en deux ou plusieurs autres, le répertoire avec le plus de noms, "gagne".
• b) Évitez la détection de renommage de répertoire pour un chemin, si ce chemin est la source d'un renommage de chaque côté d'une fusion.
• c) N'appliquez des renommages de répertoire implicites aux répertoires que si l'autre côté de l'historique est celui qui effectue le changement de nom.

Objectif

• Utilisation _{(inspiré de Smar , emprunté à Exherbo )}git am
• Ajouter l'historique de validation des fichiers copiés / déplacés
• D'un répertoire à l'autre
• Ou d'un référentiel à un autre

Limitation

• Les balises et les branches ne sont pas conservées
• L'historique est coupé lors du changement de nom du fichier de chemin (renommer le répertoire)

Sommaire

1. Extraire l'historique au format e-mail à l'aide
   git log --pretty=email -p --reverse --full-index --binary
2. Réorganiser l'arborescence des fichiers et mettre à jour les noms de fichiers
3. Ajouter un nouvel historique à l'aide
   cat extracted-history | git am --committer-date-is-author-date

1. Extraire l'historique au format e-mail

Exemple: l' histoire Extrait du file3, file4etfile5

my_repo
├── dirA
│   ├── file1
│   └── file2
├── dirB            ^
│   ├── subdir      | To be moved
│   │   ├── file3   | with history
│   │   └── file4   | 
│   └── file5       v
└── dirC
    ├── file6
    └── file7

Définir / nettoyer la destination

export historydir=/tmp/mail/dir       # Absolute path
rm -rf "$historydir"    # Caution when cleaning the folder

Extraire l'historique de chaque fichier au format email

cd my_repo/dirB
find -name .git -prune -o -type d -o -exec bash -c 'mkdir -p "$historydir/${0%/*}" && git log --pretty=email -p --stat --reverse --full-index --binary -- "$0" > "$historydir/$0"' {} ';'

Malheureusement option --followou --find-copies-harderne peut pas être combinée avec --reverse. C'est pourquoi l'historique est coupé lorsque le fichier est renommé (ou lorsqu'un répertoire parent est renommé).

Historique temporaire au format e-mail:

/tmp/mail/dir
    ├── subdir
    │   ├── file3
    │   └── file4
    └── file5

Dan Bonachea suggère d'inverser les boucles de la commande de génération de journaux git dans cette première étape: plutôt que d'exécuter git log une fois par fichier, exécutez-le exactement une fois avec une liste de fichiers sur la ligne de commande et générez un seul journal unifié. De cette façon, les validations qui modifient plusieurs fichiers restent une seule validation dans le résultat, et toutes les nouvelles validations conservent leur ordre relatif d'origine. Notez que cela nécessite également des modifications à la deuxième étape ci-dessous lors de la réécriture des noms de fichiers dans le journal (désormais unifié).

2. Réorganisez l'arborescence des fichiers et mettez à jour les noms de fichiers

Supposons que vous souhaitiez déplacer ces trois fichiers dans cet autre référentiel (il peut s'agir du même référentiel).

my_other_repo
├── dirF
│   ├── file55
│   └── file56
├── dirB              # New tree
│   ├── dirB1         # from subdir
│   │   ├── file33    # from file3
│   │   └── file44    # from file4
│   └── dirB2         # new dir
│        └── file5    # from file5
└── dirH
    └── file77

Réorganisez donc vos fichiers:

cd /tmp/mail/dir
mkdir -p dirB/dirB1
mv subdir/file3 dirB/dirB1/file33
mv subdir/file4 dirB/dirB1/file44
mkdir -p dirB/dirB2
mv file5 dirB/dirB2

Votre historique temporaire est maintenant:

/tmp/mail/dir
    └── dirB
        ├── dirB1
        │   ├── file33
        │   └── file44
        └── dirB2
             └── file5

Modifiez également les noms de fichiers dans l'historique:

cd "$historydir"
find * -type f -exec bash -c 'sed "/^diff --git a\|^--- a\|^+++ b/s:\( [ab]\)/[^ ]*:\1/$0:g" -i "$0"' {} ';'

3. Appliquer une nouvelle histoire

Votre autre dépôt est:

my_other_repo
├── dirF
│   ├── file55
│   └── file56
└── dirH
    └── file77

Appliquer des validations à partir de fichiers d'historique temporaires:

cd my_other_repo
find "$historydir" -type f -exec cat {} + | git am --committer-date-is-author-date

--committer-date-is-author-dateconserve les horodatages de validation d'origine (commentaire de Dan Bonachea ).

Votre autre dépôt est maintenant:

my_other_repo
├── dirF
│   ├── file55
│   └── file56
├── dirB
│   ├── dirB1
│   │   ├── file33
│   │   └── file44
│   └── dirB2
│        └── file5
└── dirH
    └── file77

Utilisez git statuspour voir le nombre de commits prêts à être poussés :-)

Astuce supplémentaire: vérifiez les fichiers renommés / déplacés dans votre référentiel

Pour répertorier les fichiers renommés:

find -name .git -prune -o -exec git log --pretty=tformat:'' --numstat --follow {} ';' | grep '=>'

Plus de personnalisations: vous pouvez exécuter la commande à l' git logaide des options --find-copies-harderou --reverse. Vous pouvez également supprimer les deux premières colonnes en utilisant cut -f3-et en accueillant le motif complet '{. * =>. *}'.

find -name .git -prune -o -exec git log --pretty=tformat:'' --numstat --follow --find-copies-harder --reverse {} ';' | cut -f3- | grep '{.* => .*}'

J'ai suivi ce processus en plusieurs étapes pour déplacer le code vers le répertoire parent et conserver l'historique.

Étape 0: création d'une «historique» de branche à partir de «maître» pour la conservation

Étape 1: utilisé l' outil git-filter-repo pour réécrire l'historique. Cette commande ci-dessous a déplacé le dossier «FolderwithContentOfInterest» à un niveau supérieur et modifié l'historique de validation correspondant

git filter-repo --path-rename ParentFolder/FolderwithContentOfInterest/:FolderwithContentOfInterest/ --force

Étape 2: à ce moment, le référentiel GitHub a perdu son chemin de référentiel distant. Ajout d'une référence à distance

git remote add origin [email protected]:MyCompany/MyRepo.git

Étape 3: extraire des informations sur le référentiel

git pull

Étape 4: connectez la branche locale perdue à la branche d'origine

git branch --set-upstream-to=origin/history history

Étape 5: résoudre le conflit de fusion pour la structure de dossiers si vous y êtes invité

Étape 6: Poussez !!

git push

Remarque: L'historique modifié et le dossier déplacé semblent déjà avoir été validés. enter code here

Terminé. Le code se déplace vers le répertoire parent / souhaité en gardant l'historique intact!

Bien que le cœur de Git, la plomberie Git ne garde pas la trace des renommages, l'historique que vous affichez avec le journal Git "porcelaine" peut les détecter si vous le souhaitez.

Pour une git logutilisation donnée, l'option -M:

git log -p -M

Avec une version actuelle de Git.

Cela fonctionne aussi pour d'autres commandes git diff.

Il existe des options pour rendre les comparaisons plus ou moins rigoureuses. Si vous renommez un fichier sans apporter de modifications importantes au fichier en même temps, il est plus facile pour Git log et ses amis de détecter le renommage. Pour cette raison, certaines personnes renomment des fichiers dans un commit et les modifient dans un autre.

L'utilisation du processeur a un coût chaque fois que vous demandez à Git de trouver où les fichiers ont été renommés, que vous l'utilisiez ou non, et quand, c'est à vous de décider.

Si vous souhaitez que votre historique soit toujours signalé avec la détection de renommage dans un référentiel particulier, vous pouvez utiliser:

git config diff.renames 1

Les fichiers se déplaçant d'un répertoire à un autre sont détectés. Voici un exemple:

commit c3ee8dfb01e357eba1ab18003be1490a46325992
Author: John S. Gruber <[email protected]>
Date:   Wed Feb 22 22:20:19 2017 -0500

    test rename again

diff --git a/yyy/power.py b/zzz/power.py
similarity index 100%
rename from yyy/power.py
rename to zzz/power.py

commit ae181377154eca800832087500c258a20c95d1c3
Author: John S. Gruber <[email protected]>
Date:   Wed Feb 22 22:19:17 2017 -0500

    rename test

diff --git a/power.py b/yyy/power.py
similarity index 100%
rename from power.py
rename to yyy/power.py

Veuillez noter que cela fonctionne chaque fois que vous utilisez diff, pas seulement avec git log. Par exemple:

$ git diff HEAD c3ee8df
diff --git a/power.py b/zzz/power.py
similarity index 100%
rename from power.py
rename to zzz/power.py

À titre d'essai, j'ai apporté une petite modification dans un fichier dans une branche de fonctionnalité et je l'ai validée, puis dans la branche principale, j'ai renommé le fichier, validé, puis j'ai apporté une petite modification dans une autre partie du fichier et je l'ai validé. Lorsque je suis allé dans la branche de fonctionnalité et que j'ai fusionné à partir de master, la fusion a renommé le fichier et fusionné les modifications. Voici la sortie de la fusion:

 $ git merge -v master
 Auto-merging single
 Merge made by the 'recursive' strategy.
  one => single | 4 ++++
  1 file changed, 4 insertions(+)
  rename one => single (67%)

Le résultat a été un répertoire de travail avec le fichier renommé et les deux modifications de texte effectuées. Il est donc possible pour Git de faire la bonne chose malgré le fait qu'il ne suit pas explicitement les renommages.

_{Il s'agit d'une réponse tardive à une ancienne question, donc les autres réponses peuvent être correctes pour la version Git à l'époque.}

Créez d'abord un commit autonome avec juste un renommage.

Ensuite, toute modification éventuelle du contenu du fichier est placée dans la validation distincte.

Pour renommer un répertoire ou un fichier (je ne connais pas grand-chose aux cas complexes, il peut donc y avoir quelques mises en garde):

git filter-repo --path-rename OLD_NAME:NEW_NAME

Pour renommer un répertoire dans des fichiers qui le mentionnent (il est possible d'utiliser des rappels, mais je ne sais pas comment):

git filter-repo --replace-text expressions.txt

expressions.txtest un fichier rempli de lignes comme literal:OLD_NAME==>NEW_NAME(il est possible d'utiliser RE avec Python regex:ou glob avecglob: ).

Pour renommer un répertoire dans les messages de commit:

git-filter-repo --message-callback 'return message.replace(b"OLD_NAME", b"NEW_NAME")'

Les expressions régulières de Python sont également prises en charge, mais elles doivent être écrites en Python, manuellement.

Si le référentiel est d'origine, sans télécommande, vous devrez ajouter --force pour forcer une réécriture. (Vous pouvez créer une sauvegarde de votre référentiel avant de le faire.)

Si vous ne souhaitez pas conserver les références (elles seront affichées dans l'historique des branches de Git GUI), vous devrez les ajouter --replace-refs delete-no-add.

Déplacez simplement le fichier et mettez en scène avec:

git add .

Avant de valider, vous pouvez vérifier l'état:

git status

Cela montrera:

Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
        renamed:    old-folder/file.txt -> new-folder/file.txt

J'ai testé avec Git version 2.26.1.

Extrait de la page d'aide de GitHub .

Je fais déplacer les fichiers et ensuite

git add -A

qui met dans la zone de saturation tous les fichiers supprimés / nouveaux. Ici, git se rend compte que le fichier est déplacé.

git commit -m "my message"
git push

Je ne sais pas pourquoi mais cela fonctionne pour moi.