git merge: appliquer les modifications au code déplacé dans un autre fichier

Je cherche un assez costaud git merge manœuvre de la droite maintenant. Un problème que je suis à venir à travers, c'est que j'ai apporté quelques modifications à certains de code dans ma branche, mais mon collègue a déplacé ce code dans un nouveau fichier dans sa direction. Alors, quand je n'ai git merge my_branch his_branch, git n'a pas remarqué que le code dans le nouveau fichier est le même que l'ancien, et donc aucun de mes modifications sont là.

Quelle est la meilleure façon d'aller sur l'application de mes changements de nouveau le code dans les nouveaux fichiers. Je ne vais pas avoir trop de problèmes à trouver qui commet doivent être renouvelés (je peux utiliser git log --stat). Mais autant que je sache, il n'est aucun moyen d'obtenir git pour réappliquer les modifications dans les nouveaux fichiers. La meilleure chose que je vois est de faire manuellement réappliquer les modifications, ce qui n'est pas à la recherche comme une bonne idée.

Je sais que git reconnaît les gouttes, pas les fichiers, donc il doit sûrement y avoir un moyen de lui dire, "d'appliquer ce code exact du changement à partir de ce commit, sauf de ne pas où il était mais où il est maintenant dans ce nouveau fichier".

  • Pas exactement le même, mais ici, c'est une question similaire, avec une bonne anwsers qui pourraient s'appliquer: stackoverflow.com/questions/2701790/...
  • Aucune des réponses pour tenter d'expliquer pourquoi git n'est pas en mesure d'effectuer des fusions comme cela automatiquement. Je pensais que c'était censé être assez intelligent pour détecter renomme et effectuer la fusion automatiquement?
  • Peut-être que ce n'était pas vrai, lorsque la question a été posée, mais les versions modernes de git (je suis en utilisant 1.9.5) peut fusionner des modifications à l'ensemble de renommé et déplacé des fichiers. Il y a même un --rename-threshold option pour ajuster le degré de similarité qui est nécessaire.
  • qui ne fonctionnera que si vous le faites à la vanille, rebase de l'amont de la branche, mais vous devez toujours exécuter des ennuis si vous êtes la cueillette de cerises ou de retour-le transfert d'une série de changements qui peuvent ne pas inclure le commit qui renomme les fichiers.
InformationsquelleAutor asmeurer | 2010-08-16
  1. 110

    J'ai eu un problème similaire, et je résolus par la relocalisation de mon travail pour correspondre à la cible de l'organisation des fichiers.

    Dire que vous avez modifié original.txt sur votre branche (la local branche), mais sur la branche master, original.txt a été copié à un autre, dire copy.txt.
    Cette copie a été faite dans un commit qui nous nom de commettre CP.

    Vous voulez appliquer toutes vos modifications locales, s'engage A et B ci-dessous, qui ont été faites sur original.txt, pour le nouveau fichier copy.txt.

     ---- X -----CP------ (master)
       \ 
        \--A---B--- (local)

    Créer un jetable branche move au point de départ de vos modifications avec git branch move X. C'est-à-dire, mettre le move direction générale de commettre X, celle d'avant les commits que vous souhaitez fusionner; le plus probable, c'est l'engager à partir de laquelle vous ramifié pour appliquer vos modifications. En tant qu'utilisateur @digory doo écrit ci-dessous, vous pouvez faire git merge-base master local pour trouver X.

     ---- X (move)-----CP----- (master)
       \ 
        \--A---B--- (local)

    Sur cette branche, l'émission d'un renommage de commande:

    git mv original.txt copy.txt

    Cette renomme le fichier. Notez que copy.txt n'existe pas encore dans votre arbre à ce point.

    Validez vos changements (nous le nom de ce commit MV).

            /--MV (move)
       /
 ---- X -----CP----- (master)
       \ 
        \--A---B--- (local)

    Vous pouvez maintenant rebase votre travail sur le dessus de move:

    git rebase move local

    Cela devrait fonctionner sans problème, et vos modifications sont appliquées à copy.txt dans votre succursale locale.

            /--MV (move)---A'---B'--- (local)
       /
 ---- X -----CP----- (master)

    Maintenant, vous n'avez pas forcément envie ou le besoin d'avoir de s'engager MV dans votre branche principale de l'histoire, parce que l'opération de déplacement peut entraîner un conflit avec l'opération de copie à commettre CP dans la branche principale.

    Vous n'avez qu'à rebase votre travail encore une fois, en supprimant l'opération de déplacement, comme suit:

    git rebase move local --onto CP

    ... où CP est le commit où copy.txt a été introduit dans l'autre branche.
    Cette rebases tous les changements sur copy.txt sur le dessus de la CP commettre.
    Maintenant, votre local branche est exactement comme si vous avez toujours modifié copy.txt et pas original.txt, et vous pouvez continuer à fusionner avec d'autres.

                    /--A''---B''-- (local)
               /
 -----X-------CP----- (master)

    Il est important que les modifications sont appliquées sur CP ou autrement copy.txt n'existerait pas et les modifications seront appliquées sur original.txt.

    Espère que c'est clair.
    Cette réponse est tardive, mais cela peut être utile à quelqu'un d'autre.

    • C'est beaucoup de travail, mais je pense que cela devrait fonctionner sur le principe. Je pense que vous aurez plus de chance avec fusion que cela, cependant.
    • Cette solution implique de base commandes git, contrairement à la modification de patchs ou de l'utilisation de patch (ce qui implique aussi potentiellement beaucoup de travail), et c'est pourquoi j'ai pensé qu'il pourrait être intéressant de le montrer. Notez également que j'ai pris plus de temps pour écrire la réponse que de réellement appliquer les modifications, dans mon cas. À quelle étape serait de vous la recommander à l'aide d'une fusion? et pourquoi? La seule différence que je vois est que par la relocalisation, je fais un temporaire s'engager c'est plus tard rejeté (commit MV), ce qui n'est pas possible avec des fusions.
    • Avec cela, vous avez plus de chances de faire face à des conflits de fusion, parce que vous avez à faire face à chaque commit, alors qu'avec une fusion de vous traiter avec tout à la fois, ce qui signifie que certains des changements qui pourraient avoir lieu avec un rebase serait inexistant avec une fusion. Ce que je voudrais faire est de fusionner, puis déplacez manuellement le fichier fusionné. Peut-être que j'ai mal compris l'idée de votre réponse.
    • J'ai ajouté quelques ASCII arbres à clarifier la démarche. Regaring fusion vs rebase dans ce cas: ce que je veux faire est de prendre toutes les modifications sur les "original.txt" dans ma branche et de les appliquer à 'copy.txt" dans la branche master, parce que, pour une raison quelconque, 'original.txt" a été copié (et pas déplacé) en "copy.txt" à un certain point. Après cette copie, 'original.txt" peut aussi avoir évolué sur la branche master. Si j'ai fusionné directement, mes modifications locales original.txt serait appliqué à la modification de original.txt dans la branche principale, ce qui serait difficile à fusionner. Ce qui concerne.
    • Je vois. Je recommanderais faire juste git merge local de move, puis manuellement copier le fichier d'origine local branche. Cela a git de faire moins de travail pour vous (vous êtes en copiant manuellement le fichier), mais il sera plus facile parce que les conflits de fusion sont plus simples lors de la fusion que lors de l'année de référence.
    • De toute façon, même si, je crois que cette solution fonctionne (même si j'ai, heureusement, n'ont pas une situation à l'essayer en ce moment), donc pour l'instant je vais le marquer comme réponse.
    • Je vois comment vous pouvez fusionner local de move, en effet, et puis déplacez le fichier. Dans la pratique, cela dépend du contexte et de goût. Je voudrais juste souligner que ces rebase opérations sont peu susceptibles d'introduire des conflits par eux-mêmes (il peut y avoir conflit entre local et master par la suite, mais c'est une autre question). Merci de bien vouloir accepter cette réponse 🙂
    • Le problème, c'est que vous pouvez avoir une branche qui fusionne proprement, mais rebases avec des conflits, parce que plus tard, s'engage à "enlever" les conflits. De toute façon, si littéralement déplacer le fichier se sent trop "de l'onu-git-ish" pour vous, vous pouvez toujours utiliser git pour le faire: git checkout move -- file.
    • Je comprends pourquoi la résolution des conflits de fusion peut être préféré plus de cela, pour la raison que vous avez donné. Mais il est certainement un cas de rebase des opérations et celui-ci semble le plus approprié. Des conflits peuvent surgir lors de l'année de référence local de X à CP, et malheureusement, si cela est le cas, cela dépend du contexte réel; ensuite, vous pouvez décider qu'il est plus efficace de copier le fichier résultant, ou tout ce qui fonctionne, que pour résoudre chaque conflit dans le rebase. Je ne débattrai pas, car cela pourrait être le bon choix dans la pratique.
    • Ce travail sera si copy.txt réellement existé à l'avance et il a été remplacé par le CP engager?
    • Oui, je ne vois pas de problème avec ça.
    • Dans ce scénario, je reçois un conflit lors de l'année de référence avec git rebase move local. Suis-je en train de faire quelque chose de mal?
    • J'ai un peu pensé à elle. Si votre original.txt est vide, vous obtenez alors le conflit de fusion lors de l'année de référence, mais si votre original.txt a contenu, alors il fonctionne.
    • Ok, j'ai essayé avec des branches et un tel qui fonctionne, je vais devoir l'essayer et voir si ça peut fonctionner avec plusieurs espaces de stockage locaux dans le futur... j'ai utilisé git tag de commande pour créer des étiquettes dans ce tutoriel.
    • Toujours pas sûr si des modifications ultérieures original.txt quand même dans la copie mais... vais essayer alors maintenant, sans avoir terminé le tutoriel complet... essayer cette après délivrance de la commande rebase.
    • Si j'ai soudain réalisé que ce serait bizarre... ce serait aller vice versa... WOW... git est complexe et très difficile à utiliser ! mais peut être utile si un jour fonctionne 😉
    • Avoir ce sens devrait être utile si, en supposant que original.txt pour copy.txt astuce peut être utilisée aussi pour travailler sur "coupée en deux" fichiers... et puis j'espère que les modifications ultérieures original.txt peut-être ré-appliquée à la copie de copy.txt il y a un autre débordement de pile sujet sur ce bien (le mien) et il y a un script sur github pour le fractionnement des fichiers... je crois qu'il utilise une technique similaire voulais voir cette technique dans l'action manuellement... plutôt intéressant.
    • Le script ne semble pas faire la re-fonder, par contre... pas sûr à ce sujet. Va demander à ce que le script ne le fait pas.
    • Ok intéressant jusqu'à présent, au lieu de re-fonder j'ai essayé de re-fusionner so far so good, obtenez un conflit lors de la tentative de fusion originale avec coupée en deux fichiers, mais c'est probablement là où je devrais "correctif" de l'histoire" comme dans le tutoriel vous essayez alors maintenant
    • J'ai essayé un git rm original.txt cela ne fonctionne pas.. il a résolu le conflit, mais la fusion n'a pas mis à jour les fichiers splittés... je devrais probablement avoir fait quelque chose d'autre... peut-être le tuer dans l'histoire ou quelque chose
    • Va donner le script de l'essayer parce que je suis se marre... j'espère que ça va mieux fonctionner que d'essayer de trouver une manière manuelle basée sur la fusion... ne veux essayer et garder l'histoire intacte.
    • Hmmm l'année de référence peut être nécessaire pour éviter ce conflit de fusion... vais essayer d'origine tutoriel une fois de plus... ou j'aurais essayé un renommage de livraison antérieure ou quelque chose de pas sûr si c'est possible peut-être pas... hmmm
    • Abandonner pour l'instant sur cette méthode... va essayer la méthode de script.
    • Essayé le fichier de script aussi ne fonctionne pas... les erreurs, diviser le fichier ne fait pas partie du référentiel de... demain je peut essayer cette nouvelle base de nouveau pour voir si je peux le faire fonctionner... et peut envelopper ma tête autour de lui...
    • Essayé de faire de mon approche résultat: fatal: le refus de fusionner sans rapport avec les histoires trop drôle.
    • Vais essayer a force de voir ce que cela donne: --allow-indépendants-histoires, travaillé mais pas de réelle incidence sur la mesure va essayer certaines des modifications apportées aux fichiers voir ce qui se passe
    • Oh, attendez, un fichier a été quelque chose de dupliquer comme prédit par moi... hmmm comment éviter la duplication... vais essayer de le renommer truc voir si cela aide
    • Jusqu'à présent git s'est avéré être un gaspillage total de temps... ce qu'un total morceau de merde. Je commence à comprendre pourquoi le développement open source va tellement lent... c'1. complètement demande de la coopération, sinon le modèle se décompose complètement et 2. c'est très mal adapté pour la restructuration par le code... même avec la pleine coopération de tout le monde devra attendre jusqu'à la restructuration est terminée, puis l'utiliser, s'ils ne font pas les choses deviennent incroyablement difficile apperently.
    • J'espère juste qu'il n'est pas un gaspillage total de temps, a fait faire un bon document pour moi de commandes fréquemment utilisées et demain je peux encore essayé ce rebase méthode voir si elle n'a rien à tout ce qui est utilisable...
    • Merci de nous tenir à jour avec les live tweets.

    InformationsquelleAutor coredump
  2. 27

    Vous pouvez toujours utiliser git diff (ou git format-patch) pour générer le patch, puis aller modifier manuellement les noms de fichiers dans le patch, et de l'appliquer avec git apply (ou git am).

    À court de cela, le seul moyen c'est d'aller travailler est automatiquement si git renommer détection peut comprendre que les anciens et les nouveaux fichiers sont la même chose - on dirait qu'ils ne sont pas vraiment dans votre cas, seulement une partie d'entre eux. C'est vrai que git utilise les gouttes, pas les fichiers, mais un blob est juste le contenu d'un dossier complet, sans le nom de fichier et les métadonnées attachées. Donc, si vous avez un morceau de code de déplacés entre les deux fichiers, ils ne sont pas vraiment les mêmes blob - le reste de la goutte du contenu est différent, tout le morceau en commun.

    • Eh bien, c'est la meilleure réponse à ce jour. Je ne pouvais pas comprendre comment le faire git format-patch de travail pour une livraison. Si je ne git format-patch SHA1, il génère tout un tas de fichiers de correctif pour l'ensemble de l'histoire. Mais je suppose que git show SHA1 > diff.patch fonctionnera tout aussi bien.
    • utiliser le -1 option. En mode de fonctionnement normal pour format-patch est une révision de la gamme, comme origin/master..master, de sorte que vous pouvez facilement préparer un patch de la série.
    • En fait, une autre note. git apply et git am sont trop pointilleux, parce qu'ils veulent la même chose sur les numéros de ligne. Mais je suis actuellement en train de réussir avec les UNIX patch de commande.
    InformationsquelleAutor Cascabel
  3. 17

    Ici est un de fusion solution de la rencontre d'un conflit de fusion avec les renommer et de les éditer et de les résoudre avec mergetool reconnaissance de la bonne 3 fusionner des fichiers source.

    • Après une fusion échoue en raison de "supprimer le fichier' que vous vous rendez compte a été renommé et modifié:

      1. Vous abandonner à la fusion.
      2. Commettre renommé les fichiers sur votre branche.
      3. Et de fusionner à nouveau.

    De plain-pied à travers:

    Créer un file.txt:

    $ git init
Initialized empty Git repository in /tmp/git-rename-and-modify-test/.git/

$ echo "A file." > file.txt
$ git add file.txt
$ git commit -am "file.txt added."
[master (root-commit) 401b10d] file.txt added.
 1 file changed, 1 insertion(+)
 create mode 100644 file.txt

    Créer une branche où vous pourrez modifier par la suite:

    $ git branch branch-with-edits
Branch branch-with-edits set up to track local branch master.

    Créer les renommer et de les éditer sur le master:

    $ git mv file.txt renamed-and-edited.txt
$ echo "edits on master" >> renamed-and-edited.txt 
$ git commit -am "file.txt + edits -> renamed-and-edited.txt."
[master def790f] file.txt + edits -> renamed-and-edited.txt.
 2 files changed, 2 insertions(+), 1 deletion(-)
 delete mode 100644 file.txt
 create mode 100644 renamed-and-edited.txt

    Swap de la direction générale, et de modifier par là aussi:

    $ git checkout branch-with-edits 
Switched to branch 'branch-with-edits'
Your branch is behind 'master' by 1 commit, and can be fast-forwarded.
  (use "git pull" to update your local branch)
$ 
$ echo "edits on branch" >> file.txt 
$ git commit -am "file.txt edited on branch."
[branch-with-edits 2c4760e] file.txt edited on branch.
 1 file changed, 1 insertion(+)

    Tentative de fusion de maître:

    $ git merge master
CONFLICT (modify/delete): file.txt deleted in master and modified in HEAD. Version HEAD of file.txt left in tree.
Automatic merge failed; fix conflicts and then commit the result.

    Avis le conflit est difficile à résoudre et que les fichiers ont été renommés. Abandonner, imiter le renommer:

    $ git merge --abort
$ git mv file.txt renamed-and-edited.txt
$ git commit -am "Preparing for merge; Human noticed renames files were edited."
[branch-with-edits ca506da] Preparing for merge; Human noticed renames files were edited.
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename file.txt => renamed-and-edited.txt (100%)

    Essayer de fusionner de nouveau:

    $ git merge master
Auto-merging renamed-and-edited.txt
CONFLICT (add/add): Merge conflict in renamed-and-edited.txt
Recorded preimage for 'renamed-and-edited.txt'
Automatic merge failed; fix conflicts and then commit the result.

    Grand! Fusionner les résultats à un niveau "normal" les conflits qui peuvent être résolus avec mergetool:

    $ git mergetool
Merging:
renamed-and-edited.txt

Normal merge conflict for 'renamed-and-edited.txt':
  {local}: created file
  {remote}: created file
$ git commit 
Recorded resolution for 'renamed-and-edited.txt'.
[branch-with-edits 2264483] Merge branch 'master' into branch-with-edits
    • Intéressant. Je vais essayer la prochaine fois que je rencontre ce problème.
    • Dans cette solution, il me semble que la première étape, la fusion qui est interrompue, n'est utile que pour savoir quels fichiers ont été renommés et édité à distance. Si vous savez à l'avance. Vous pouvez ignorer cette étape et, fondamentalement, la solution est tout simplement de renommer manuellement les fichiers localement et puis les fusionner et de résoudre les conflits, comme d'habitude.
    • Je vous remercie. Ma situation est que j'ai déménagé B.txt -> C.txt et A.txt -> B.txt avec git mv, et git ne pouvait pas s'adapter automatiquement les conflits de fusion correctement (a été d'obtenir des conflits de fusion entre les anciens B.txt et de nouvelles B.txt). En utilisant cette méthode, les conflits de fusion sont maintenant entre les fichiers corrects.
    InformationsquelleAutor Vincent Scheib