Wie kann git eine gelöschte und eine neue Datei als Datei verschieben markieren?

Ich habe eine Datei manuell verschoben und dann geändert. Laut Git handelt es sich um eine neue und eine entfernte Datei. Gibt es eine Möglichkeit, Git zu zwingen, es als Dateiverschiebung zu behandeln?

Git erkennt das Verschieben / Umbenennen automatisch, wenn Ihre Änderung nicht zu schwerwiegend ist. Nur git adddie neue Datei und git rmdie alte Datei. git statuszeigt dann an, ob die Umbenennung erkannt wurde.

Für das Verschieben in Verzeichnissen müssen Sie möglicherweise Folgendes tun:

1. CD an den Anfang dieser Verzeichnisstruktur.
2. Lauf git add -A .
3. Führen Sie aus git status, um zu überprüfen, ob die "neue Datei" jetzt eine "umbenannte" Datei ist

Wenn der Git-Status weiterhin "Neue Datei" und nicht "Umbenannt" anzeigt, müssen Sie den Ratschlägen von Hank Gay folgen und den Umzug und die Änderung in zwei separaten Commits durchführen.

Führen Sie die Verschiebung und Änderung in separaten Commits durch.

Es ist alles eine Wahrnehmungssache. Git ist im Allgemeinen ziemlich gut darin, Bewegungen zu erkennen, da GIT ein Content-Tracker ist

Alles, was wirklich davon abhängt, ist, wie Ihr "stat" es anzeigt. Der einzige Unterschied ist hier die -M-Flagge.

git log --stat -M

commit 9c034a76d394352134ee2f4ede8a209ebec96288
Author: Kent Fredric
Date:   Fri Jan 9 22:13:51 2009 +1300


        Category Restructure

     lib/Gentoo/Repository.pm                |   10 +++++-----
     lib/Gentoo/{ => Repository}/Base.pm     |    2 +-
     lib/Gentoo/{ => Repository}/Category.pm |   12 ++++++------
     lib/Gentoo/{ => Repository}/Package.pm  |   10 +++++-----
     lib/Gentoo/{ => Repository}/Types.pm    |   10 +++++-----
     5 files changed, 22 insertions(+), 22 deletions(-)

git log --stat

commit 9c034a76d394352134ee2f4ede8a209ebec96288
Author: Kent Fredric
Date:   Fri Jan 9 22:13:51 2009 +1300

    Category Restructure

 lib/Gentoo/Base.pm                |   36 ------------------------
 lib/Gentoo/Category.pm            |   51 ----------------------------------
 lib/Gentoo/Package.pm             |   41 ---------------------------
 lib/Gentoo/Repository.pm          |   10 +++---
 lib/Gentoo/Repository/Base.pm     |   36 ++++++++++++++++++++++++
 lib/Gentoo/Repository/Category.pm |   51 ++++++++++++++++++++++++++++++++++
 lib/Gentoo/Repository/Package.pm  |   41 +++++++++++++++++++++++++++
 lib/Gentoo/Repository/Types.pm    |   55 +++++++++++++++++++++++++++++++++++++
 lib/Gentoo/Types.pm               |   55 -------------------------------------
 9 files changed, 188 insertions(+), 188 deletions(-)

Git Hilfe Protokoll

   -M
       Detect renames.

   -C
       Detect copies as well as renames. See also --find-copies-harder.

git diff -Moder git log -Msollten solche Änderungen automatisch als Umbenennung mit geringfügigen Änderungen erkennen , solange sie tatsächlich vorhanden sind. Wenn Ihre geringfügigen Änderungen nicht geringfügig sind, können Sie die Ähnlichkeit verringern, z

$ git log -M20 -p --stat

um es von der Standardeinstellung von 50% auf 20% zu reduzieren.

Hier ist eine schnelle und schmutzige Lösung für eine oder mehrere umbenannte und geänderte Dateien, die nicht festgeschrieben sind.

Angenommen, die Datei wurde benannt foound heißt jetzt bar:

1. Umbenennen barin einen temporären Namen:

   mv bar side
   

2. Kasse foo:

   git checkout HEAD foo
   

3. Benennen Sie fooauf barmit Git:

   git mv foo bar
   

4. Benennen Sie nun Ihre temporäre Datei wieder in um bar.

   mv side bar
   

Dieser letzte Schritt bringt Ihren geänderten Inhalt zurück in die Datei.

Dies kann zwar funktionieren, aber wenn sich der Inhalt der verschobenen Datei zu stark vom ursprünglichen Git unterscheidet, ist es effizienter, zu entscheiden, dass es sich um ein neues Objekt handelt. Lassen Sie mich demonstrieren:

$ git status
On branch workit
Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)

    new file:   .gitignore
    renamed:    README -> README.md

Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git checkout -- <file>..." to discard changes in working directory)

    modified:   README.md
    modified:   work.js

$ git add README.md work.js # why are the changes unstaged, let's add them.
$ git status
On branch workit
Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)

    new file:   .gitignore
    deleted:    README
    new file:   README.md
    modified:   work.js

$ git stash # what? let's go back a bit
Saved working directory and index state WIP on dir: f7a8685 update
HEAD is now at f7a8685 update
$ git status
On branch workit
Untracked files:
  (use "git add <file>..." to include in what will be committed)

    .idea/

nothing added to commit but untracked files present (use "git add" to track)
$ git stash pop
Removing README
On branch workit
Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)

    new file:   .gitignore
    new file:   README.md

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:    README
    modified:   work.js

Dropped refs/stash@{0} (1ebca3b02e454a400b9fb834ed473c912a00cd2f)
$ git add work.js
$ git status
On branch workit
Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)

    new file:   .gitignore
    new file:   README.md
    modified:   work.js

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:    README

$ git add README # hang on, I want it removed
$ git status
On branch workit
Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)

    new file:   .gitignore
    deleted:    README
    new file:   README.md
    modified:   work.js

$ mv README.md Rmd # Still? Try the answer I found.
$ git checkout README
error: pathspec 'README' did not match any file(s) known to git.
$ git checkout HEAD README # Ok the answer needed fixing.
$ git status
On branch workit
Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)

    new file:   .gitignore
    new file:   README.md
    modified:   work.js

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:    README.md
    modified:   work.js

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

    Rmd

$ git mv README README.md
$ git status
On branch workit
Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)

    new file:   .gitignore
    renamed:    README -> README.md
    modified:   work.js

Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git checkout -- <file>..." to discard changes in working directory)

    modified:   work.js

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

    Rmd

$ mv Rmd README.md
$ git status
On branch workit
Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)

    new file:   .gitignore
    renamed:    README -> README.md
    modified:   work.js

Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git checkout -- <file>..." to discard changes in working directory)

    modified:   README.md
    modified:   work.js

$ # actually that's half of what I wanted; \
  # and the js being modified twice? Git prefers it in this case.

Wenn Sie davon sprechen git status, die Umbenennungen nicht anzuzeigen, versuchen Sie es git commit --dry-run -astattdessen

Wenn Sie TortoiseGit verwenden, ist es wichtig zu beachten, dass die automatische Umbenennungserkennung von Git während des Festschreibens erfolgt, die Tatsache, dass dies geschehen wird, jedoch nicht immer vorher von der Software angezeigt wird. Ich hatte zwei Dateien in ein anderes Verzeichnis verschoben und einige geringfügige Änderungen vorgenommen. Ich verwende TortoiseGit als Commit-Tool und in der Liste der vorgenommenen Änderungen wurden die Dateien angezeigt, die gelöscht und hinzugefügt und nicht verschoben wurden. Das Ausführen des Git-Status über die Befehlszeile zeigte eine ähnliche Situation. Nach dem Festschreiben der Dateien wurden sie jedoch im Protokoll umbenannt. Die Antwort auf Ihre Frage lautet also: Solange Sie nichts zu drastisches getan haben, sollte Git die Umbenennung automatisch übernehmen.

Bearbeiten: Wenn Sie die neuen Dateien hinzufügen und dann über die Befehlszeile einen Git-Status ausführen, sollte die Umbenennung vor dem Festschreiben angezeigt werden.

Bearbeiten 2: Fügen Sie in TortoiseGit außerdem die neuen Dateien im Festschreibungsdialog hinzu, aber schreiben Sie sie nicht fest. Wenn Sie dann in den Befehl Show Log gehen und sich das Arbeitsverzeichnis ansehen, werden Sie sehen, ob Git die Umbenennung vor dem Festschreiben erkannt hat.

Dieselbe Frage wurde hier gestellt: https://tortoisegit.org/issue/1389 und wurde als Fehler behoben, der hier behoben werden muss: https://tortoisegit.org/issue/1440 Es stellt sich heraus, dass es sich um ein Anzeigeproblem mit TortoiseGits Commit handelt Dialog und existiert auch irgendwie im Git-Status, wenn Sie die neuen Dateien nicht hinzugefügt haben.

Oder versuchen Sie die Antwort auf diese Frage hier von Amber ! Um es noch einmal zu zitieren:

Brechen Sie zunächst Ihr inszeniertes Hinzufügen für die manuell verschobene Datei ab:

$ git reset path/to/newfile
$ mv path/to/newfile path/to/oldfile

Verwenden Sie dann Git, um die Datei zu verschieben:

$ git mv path/to/oldfile path/to/newfile

Wenn Sie die manuelle Verschiebung bereits festgeschrieben haben, möchten Sie möglicherweise stattdessen vor der Verschiebung auf die Revision zurücksetzen und dann einfach mv von dort aus git.

Verwenden Sie den git mvBefehl zum Verschieben der Dateien anstelle der Befehle zum Verschieben des Betriebssystems: https://git-scm.com/docs/git-mv

Bitte beachten Sie, dass der git mvBefehl nur in Git-Versionen 1.8.5 und höher vorhanden ist. Möglicherweise müssen Sie Ihr Git aktualisieren, um diesen Befehl verwenden zu können.

Ich hatte dieses Problem kürzlich beim Verschieben (aber nicht Ändern) einiger Dateien.

Das Problem ist, dass Git einige Zeilenenden geändert hat, als ich die Dateien verschoben habe, und dann nicht feststellen konnte, dass die Dateien identisch waren.

Mit git mvProblem wurde das Problem behoben, aber es funktioniert nur mit einzelnen Dateien / Verzeichnissen, und ich hatte viele Dateien im Stammverzeichnis des Repositorys zu erledigen.

Eine Möglichkeit, dies zu beheben, wäre etwas Bash / Batch-Magie.

Ein anderer Weg ist der folgende

• Verschieben Sie die Dateien und git commit. Dadurch werden die Zeilenenden aktualisiert.
• Verschieben Sie die Dateien an ihren ursprünglichen Speicherort zurück, nachdem sie die neuen Zeilenenden haben, und git commit --amend
• Verschieben Sie die Dateien erneut und git commit --amend. Diesmal gibt es keine Änderung an den Zeilenenden, sodass Git glücklich ist

Für mich hat es funktioniert, alle Änderungen vor dem Festschreiben zu speichern und sie wieder herauszuholen. Dadurch analysierte git die hinzugefügten / gelöschten Dateien erneut und markierte sie korrekt als verschoben.

Es gibt wahrscheinlich eine bessere "Kommandozeilen" -Methode, und ich weiß, dass dies ein Hack ist, aber ich habe nie eine gute Lösung gefunden.

Verwenden von TortoiseGIT: Wenn Sie ein GIT-Commit haben, bei dem einige Vorgänge zum Verschieben von Dateien als Laden von Hinzufügungen / Löschungen angezeigt werden, anstatt sie umzubenennen, obwohl die Dateien nur geringfügige Änderungen aufweisen, gehen Sie folgendermaßen vor:

1. Überprüfen Sie, was Sie vor Ort getan haben
2. Checken Sie eine kleine einzeilige Änderung in einem zweiten Commit ein
3. Gehen Sie zu GIT Log in Tortoise Git
4. Wählen Sie die beiden Commits aus, klicken Sie mit der rechten Maustaste und wählen Sie "In einem Commit zusammenführen".

Das neue Commit zeigt nun die Umbenennungen der Dateien ordnungsgemäß an. Dies hilft dabei, den ordnungsgemäßen Dateiversionsverlauf aufrechtzuerhalten.

Wenn ich eine Datei gleichzeitig bearbeite, umbenenne und verschiebe, funktioniert keine dieser Lösungen. Die Lösung besteht darin, dies in zwei Commits durchzuführen (bearbeiten und umbenennen / separat verschieben) und dann fixupdas zweite Commit über git rebase -i, um es in einem Commit zu haben.

Ich verstehe diese Frage wie folgt: "Wie kann Git das Löschen einer alten Datei und das Erstellen einer neuen Datei als Dateiverschiebung erkennen?"

Ja, wenn Sie im Arbeitsverzeichnis eine alte Datei löschen und eine alte Datei einfügen, git statuswerden " deleted: old_file" und " Untracked files: ... new_file" angezeigt.

Im Staging-Index / der Staging-Ebene wird das Hinzufügen und Entfernen von Dateien mit git jedoch als Dateiverschiebung erkannt. Geben Sie dazu die folgenden Befehle ein, vorausgesetzt, Sie haben das Löschen und Erstellen mit Ihrem Betriebssystem durchgeführt:

git add new_file
git rm old_file

Wenn der Inhalt der Datei zu 50% oder mehr ähnlich ist, sollte der git statusBefehl running Folgendes ergeben:

renamed: old_file -> new_file