Gérer les renommages de fichiers dans git

Je lirais que lorsque vous renommez des fichiers dans git , vous devez valider toutes les modifications, effectuer votre renommage, puis mettre en scène votre fichier renommé. Git reconnaîtra le fichier à partir du contenu, plutôt que de le voir comme un nouveau fichier non suivi, et conservera l'historique des modifications.

Cependant, en faisant juste ce soir, j'ai fini par revenir git mv.

> $ git status
# On branch master
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#   modified:   index.html
#

Renommer ma feuille de style dans le Finder de iphone.cssàmobile.css

> $ git status
# On branch master
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#   modified:   index.html
#
# Changed but not updated:
#   (use "git add/rm <file>..." to update what will be committed)
#   (use "git checkout -- <file>..." to discard changes in working directory)
#
#   deleted:    css/iphone.css
#
# Untracked files:
#   (use "git add <file>..." to include in what will be committed)
#
#   css/mobile.css

Git pense maintenant que j'ai supprimé un fichier CSS et en ai ajouté un nouveau. Pas ce que je veux, permet d'annuler le changement de nom et de laisser git faire le travail.

> $ git reset HEAD .
Unstaged changes after reset:
M   css/iphone.css
M   index.html

Retour là où j'ai commencé.

> $ git status
# On branch master
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#   modified:   index.html
#

Permet d'utiliser à la git mvplace.

> $ git mv css/iphone.css css/mobile.css
> $ git status
# On branch master
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#   renamed:    css/iphone.css -> css/mobile.css
#
# Changed but not updated:
#   (use "git add <file>..." to update what will be committed)
#   (use "git checkout -- <file>..." to discard changes in working directory)
#
#   modified:   index.html
#

On dirait que nous sommes bons. Alors pourquoi git n'a-t-il pas reconnu le changement de nom la première fois quand j'ai utilisé le Finder?

Pour git mvla page de manuel dit

L'index est mis à jour après la réussite, […]

Donc, dans un premier temps, vous devez mettre à jour l'index par vous-même (en utilisant git add mobile.css). Cependant
git status , deux fichiers différents seront toujours affichés

$ git status
# On branch master
warning: LF will be replaced by CRLF in index.html
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#       modified:   index.html
#       new file:   mobile.css
#
# Changed but not updated:
#   (use "git add/rm <file>..." to update what will be committed)
#   (use "git checkout -- <file>..." to discard changes in working directory)
#
#       deleted:    iphone.css
#

Vous pouvez obtenir une sortie différente en exécutant git commit --dry-run -a, ce qui se traduit par ce que vous attendez:

Tanascius@H181 /d/temp/blo (master)
$ git commit --dry-run -a
# On branch master
warning: LF will be replaced by CRLF in index.html
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#       modified:   index.html
#       renamed:    iphone.css -> mobile.css
#

Je ne peux pas vous dire exactement pourquoi nous voyons ces différences entre git statuset
git commit --dry-run -a, mais voici un indice de Linus :

git ne se soucie vraiment pas de toute la "détection de renommage" en interne, et toutes les validations que vous avez faites avec des renommages sont totalement indépendantes de l'heuristique que nous utilisons ensuite pour afficher les renommages.

A dry-runutilise les vrais mécanismes de changement de nom, alors que git statusprobablement pas.

Vous devez ajouter les deux fichiers modifiés à l'index avant que git ne le reconnaisse comme un mouvement.

La seule différence entre mv old newet git mv old newest que le git mv ajoute également les fichiers à l'index.

mv old newalors git add -Aça aurait marché aussi.

Notez que vous ne pouvez pas simplement l'utiliser git add .car cela n'ajoute pas de suppressions à l'index.

Voir Différence entre "git add -A" et "git add".

Le mieux est de l'essayer par vous-même.

mkdir test
cd test
git init
touch aaa.txt
git add .
git commit -a -m "New file"
mv aaa.txt bbb.txt
git add .
git status
git commit --dry-run -a

Maintenant, git status et git commit --dry-run -a affiche deux résultats différents où git status affiche bbb.txt comme un nouveau fichier / aaa.txt est supprimé, et les commandes --dry-run montrent le renommage réel.

~/test$ git status

# On branch master
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#   new file:   bbb.txt
#
# Changes not staged for commit:
#   (use "git add/rm <file>..." to update what will be committed)
#   (use "git checkout -- <file>..." to discard changes in working directory)
#
#   deleted:    aaa.txt
#


/test$ git commit --dry-run -a

# On branch master
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#   renamed:    aaa.txt -> bbb.txt
#

Maintenant, allez-y et faites l'enregistrement.

git commit -a -m "Rename"

Vous pouvez maintenant voir que le fichier est en fait renommé et que ce qui est affiché dans git status est faux.

Morale de l'histoire: si vous n'êtes pas sûr que votre fichier ait été renommé, lancez un "git commit --dry-run -a". Si cela montre que le fichier est renommé, vous êtes prêt à partir.

Pour git 1.7.x, les commandes suivantes ont fonctionné pour moi:

git mv css/iphone.css css/mobile.css
git commit -m 'Rename folder.' 

Il n'y avait pas besoin de git add, car le fichier d'origine (c'est-à-dire css / mobile.css) était déjà dans les fichiers validés précédemment.

vous devez git add css/mobile.cssle nouveau fichier et git rm css/iphone.css, donc git le sait. alors il affichera la même sortiegit status

vous pouvez le voir clairement dans la sortie d'état (le nouveau nom du fichier):

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

et (l'ancien nom):

# Changed but not updated:
#   (use "git add/rm <file>..." to update what will be committed)

je pense que dans les coulisses git mvn'est rien de plus qu'un script wrapper qui fait exactement cela: supprimer le fichier de l'index et l'ajouter sous un nom différent

Pensons à vos fichiers du point de vue git.

Gardez à l'esprit que git ne suit aucune métadonnée sur vos fichiers

Votre référentiel a (entre autres)

$ cd repo
$ ls
...
iphone.css
...

et il est sous contrôle git:

$ git ls-files --error-unmatch iphone.css &>/dev/null && echo file is tracked
file is tracked

Testez cela avec:

$ touch newfile
$ git ls-files --error-unmatch newfile &>/dev/null && echo file is tracked
(no output, it is not tracked)
$ rm newfile

Quand tu fais

$ mv iphone.css mobile.css

Du point de vue git,

• il n'y a pas iphone.css (il est supprimé -git vous en avertit-).
• il y a un nouveau fichier mobile.css .
• Ces fichiers sont totalement indépendants.

Ainsi, git conseille sur les fichiers qu'il connaît déjà ( iphone.css ) et les nouveaux fichiers qu'il détecte ( mobile.css ) mais uniquement lorsque les fichiers sont dans l'index ou que HEAD git commence à vérifier leur contenu.

En ce moment, ni "suppression de iphone.css" ni mobile.css ne sont sur l'index.

Ajouter la suppression iphone.css à l'index

$ git rm iphone.css

git vous dit exactement ce qui s'est passé: ( iphone.css est supprimé. Il ne s'est plus rien passé)

puis ajoutez un nouveau fichier mobile.css

$ git add mobile.css

Cette fois, la suppression et le nouveau fichier sont sur l'index. Maintenant, git détecte que le contexte est le même et l'expose comme un renommage. En fait, si les fichiers sont similaires à 50%, cela détectera cela comme un renommage, ce qui vous permettra de changer un peu mobile.css tout en conservant l'opération comme un renommage.

Voir ceci est reproductible sur git diff. Maintenant que vos fichiers sont sur index, vous devez utiliser --cached. Modifiez un peu mobile.css , ajoutez-le à l'index et voyez la différence entre:

$ git diff --cached 

et

$ git diff --cached -M

-Mest l'option "détecter les renommages" pour git diff. -Msignifie -M50%(50% ou plus de similitude fera git l'exprimer comme un renommage) mais vous pouvez le réduire à -M20%(20%) si vous éditez beaucoup mobile.css.

Étape 1: renommer le fichier de l'ancien fichier en nouveau fichier

git mv #oldfile #newfile

Étape 2: git commit et ajout de commentaires

git commit -m "rename oldfile to newfile"

Étape 3: envoyez cette modification au serveur distant

git push origin #localbranch:#remotebranch

Git reconnaîtra le fichier à partir du contenu, plutôt que de le voir comme un nouveau fichier non suivi

C'est là que vous vous êtes trompé.

Ce n'est qu'après avoir ajouté le fichier, que git le reconnaîtra à partir du contenu.

Vous n'avez pas mis en scène les résultats de votre mouvement de recherche. Je crois que si vous faisiez le déplacement via le Finder et que vous le git add css/mobile.css ; git rm css/iphone.cssfaisiez, git calculerait le hachage du nouveau fichier et ne réaliserait alors que le hachage des fichiers correspond (et donc c'est un renommage).

Dans les cas où vous devez vraiment renommer les fichiers manuellement, par exemple. en utilisant un script pour renommer par lots un tas de fichiers, puis en utilisant git add -A .travaillé pour moi.

Pour les utilisateurs de Xcode: si vous renommez votre fichier dans Xcode, l'icône du badge change pour s'ajouter. Si vous effectuez une validation en utilisant XCode, vous créerez en fait un nouveau fichier et perdrez l'historique.

Une solution de contournement est facile mais vous devez le faire avant de valider en utilisant Xcode:

1. Faites un git Status sur votre dossier. Vous devez voir que les modifications par étapes sont correctes:

renommé: Project / OldName.h -> Project / NewName.h renommé: Project / OldName.m -> Project / NewName.m

1. faire un commit -m 'changement de nom'

Revenez ensuite à XCode et vous verrez le badge changé de A à M et il est sauvegardé pour valider les changements futurs en utilisant xcode maintenant.