過去のコミットを簡単に修正するにはどうすればよいですか？

私はgitの過去のコミットで1つのファイルの修正を読んだだけですが、残念ながら、受け入れられたソリューションはコミットを「並べ替え」ます。これは私が望んでいることではありません。だから私の質問です：

（無関係な）機能に取り組んでいるときに、コードにバグがあることに時々気づきます。すぐにgit blame、バグが数コミット前に導入されたことを明らかにします（私はかなりたくさんコミットしているので、通常、バグを導入したのは最新のコミットではありません）。この時点で、私は通常これを行います：

git stash                      # temporarily put my work aside
git rebase -i <bad_commit>~1   # rebase one step before the bad commit
                               # mark broken commit for editing
vim <affected_sources>         # fix the bug
git add <affected_sources>     # stage fixes
git commit -C <bad_commit>     # commit fixes using same log message as before
git rebase --continue          # base all later changes onto this

ただし、これは頻繁に発生するため、上記のシーケンスは煩わしくなります。特に「インタラクティブなリベース」は退屈です。上記のシーケンスへのショートカットはありますか？これにより、過去の任意のコミットを段階的な変更で修正できますか？これが歴史を変えることを私は完全に認識していますが、私は間違いをしていることが多いので、次のようなものが本当に好きです

vim <affected_sources>             # fix bug
git add -p <affected_sources>      # Mark my 'fixup' hungs for staging
git fixup <bad_commit>             # amend the specified commit with staged changes,
                                   # rebase any successors of bad commit on rewritten 
                                   # commit.

配管ツールなどを使用してコミットを書き換えることができるスマートスクリプトでしょうか？

更新された回答

しばらく前に、に適したログメッセージでコミットを構築するために使用できる新しい--fixup引数が追加されgit commitましたgit rebase --interactive --autosquash。したがって、過去のコミットを修正する最も簡単な方法は次のとおりです。

$ git add ...                           # Stage a fix
$ git commit --fixup=a0b1c2d3           # Perform the commit to fix broken a0b1c2d3
$ git rebase -i --autosquash a0b1c2d3~1 # Now merge fixup commit into broken commit

元の回答

これは、先ほど書いた小さなPythonスクリプトgit fixupで、元の質問で期待していたこのロジックを実装しています。スクリプトは、いくつかの変更をステージングしたと想定し、それらの変更を特定のコミットに適用します。

注：このスクリプトはWindows固有です。を使用しgit.exeてGIT_EDITOR環境変数を探して設定しますset。他のオペレーティングシステムの必要に応じてこれを調整します。

このスクリプトを使用して、「壊れたソースの修正、ステージの修正、git fixupの実行」ワークフローを正確に実装できます。

#!/usr/bin/env python
from subprocess import call
import sys

# Taken from http://stackoverflow.com/questions/377017/test-if-executable-exists-in python
def which(program):
    import os
    def is_exe(fpath):
        return os.path.exists(fpath) and os.access(fpath, os.X_OK)

    fpath, fname = os.path.split(program)
    if fpath:
        if is_exe(program):
            return program
    else:
        for path in os.environ["PATH"].split(os.pathsep):
            exe_file = os.path.join(path, program)
            if is_exe(exe_file):
                return exe_file

    return None

if len(sys.argv) != 2:
    print "Usage: git fixup <commit>"
    sys.exit(1)

git = which("git.exe")
if not git:
    print "git-fixup: failed to locate git executable"
    sys.exit(2)

broken_commit = sys.argv[1]
if call([git, "rev-parse", "--verify", "--quiet", broken_commit]) != 0:
    print "git-fixup: %s is not a valid commit" % broken_commit
    sys.exit(3)

if call([git, "diff", "--staged", "--quiet"]) == 0:
    print "git-fixup: cannot fixup past commit; no fix staged."
    sys.exit(4)

if call([git, "diff", "--quiet"]) != 0:
    print "git-fixup: cannot fixup past commit; working directory must be clean."
    sys.exit(5)

call([git, "commit", "--fixup=" + broken_commit])
call(["set", "GIT_EDITOR=true", "&&", git, "rebase", "-i", "--autosquash", broken_commit + "~1"], shell=True)

私がしていることは：

git add ...＃修正を追加します。
git commit＃コミットされましたが、間違った場所にあります。
git rebase -i HEAD〜5＃リベースのために最後の5つのコミットを調べます。

エディターが開き、直近の5つのコミットのリストが表示されます。変化する：

08e833cを選びます。良い変化1。
ピック9134ac9良い変化2。
5adda55を選択してください。
pick 400bce4良い変化3。
pick 2bc82n1悪い変更の修正。

...に：

08e833cを選びます。良い変化1。
ピック9134ac9良い変化2。
5adda55を選択してください。
f 2bc82n1悪い変更の修正。＃上に移動して、「pick」を「fixup」の「f」に変更します。
pick 400bce4良い変化3。

エディターを保存して終了すると、修正はそれが属するコミットに戻されます。

あなたがそれを数回行った後、あなたはあなたの睡眠中に数秒でそれをします。インタラクティブなリベースは、gitで本当に私を売り込んだ機能です。これ以上にとても便利です...

パーティーには少し遅れますが、著者が想像したとおりに機能する解決策があります。

これを.gitconfigに追加してください：

[alias]
    fixup = "!sh -c '(git diff-files --quiet || (echo Unstaged changes, please commit or stash with --keep-index; exit 1)) && COMMIT=$(git rev-parse $1) && git commit --fixup=$COMMIT && git rebase -i --autosquash $COMMIT~1' -"

使用例：

git add -p
git fixup HEAD~5

ただし、ステージングされていない変更がある場合は、リベースの前にそれらを隠しておく必要があります。

git add -p
git stash --keep-index
git fixup HEAD~5
git stash pop

警告を出す代わりに、エイリアスを変更して自動的に隠しておくこともできます。ただし、フィックスアップが正しく適用されない場合は、競合を修正した後、スタッシュを手動でポップする必要があります。保存とポップの両方を手動で行うと、一貫性が増し、混乱が少なくなります。

1つのコミットを修正するには：

git commit --fixup a0b1c2d3 .
git rebase --autosquash -i HEAD~2

ここで、a0b1c2d3は修正が必要なコミットで、2は変更したい+1が貼り付けられたコミットの数です。

注：-iなしでgit rebase --autosquashは機能しませんが、-iを使用すると機能します。これは奇妙です。

更新：スクリプトのよりクリーンなバージョンは、https：//github.com/deiwin/git-dotfiles/blob/docs/bin/git-fixupにあります。

私は似たようなものを探していました。ただし、このPythonスクリプトは複雑すぎるようです。そのため、私は自分の解決策をまとめました。

まず、私のgitエイリアスは次のようになります（ここから借用）：

[alias]
  fixup = !sh -c 'git commit --fixup=$1' -
  squash = !sh -c 'git commit --squash=$1' -
  ri = rebase --interactive --autosquash

これで、bash関数は非常に単純になります。

function gf {
  if [ $# -eq 1 ]
  then
    if [[ "$1" == HEAD* ]]
    then
      git add -A; git fixup $1; git ri $1~2
    else
      git add -A; git fixup $1; git ri $1~1
    fi
  else
    echo "Usage: gf <commit-ref> "
  fi
}

このコードは最初に現在のすべての変更をステージングします（自分でファイルをステージングする場合は、この部分を削除できます）。次に、フィックスアップ（必要に応じてスカッシュを使用することもできます）コミットを作成します。その後--autosquash、引数として指定したコミットの親のフラグを使用してインタラクティブなリベースを開始します。これにより、構成されたテキストエディターが開きます。そのため、すべてが期待どおりであることを確認でき、エディターを閉じるだけでプロセスが終了します。

if [[ "$1" == HEAD* ]]（から借り一部ここで、その後HEADがフィックスアップ後に変位され、あなたの（あなたが現在の変更を修正したいコミット）を基準に、あなたが使用している場合ので、たとえば、使用されている）、HEAD〜2が作成されているコミット同じコミットを参照するには、HEAD〜3を使用する必要があります。

「null」エディターを使用することで、インタラクティブなステージを回避できます。

$ EDITOR=true git rebase --autosquash -i ...

これはの/bin/true代わりにエディターとして使用され/usr/bin/vimます。プロンプトなしで、gitの提案を常に受け​​入れます。

修正ワークフローについて本当に気になったのは、毎回変更を押しつぶしたいコミットを自分で見つけなければならないことでした。これを支援する「git fixup」コマンドを作成しました。

このコマンドはフィックスアップコミットを作成し、関連するコミットをgit-depsを使用して自動的に見つけるという魔法が追加されているため、ワークフローは次のようになります。

# discover and fix typo in a previously committed change
git add -p # stage only typo fix
git fixup

# at some later point squash all the fixup commits that came up
git rebase --autosquash master

これは、ステージングされた変更が作業ツリー（マスターとHEADの間）の特定のコミットに明確に起因する場合にのみ機能します。たとえば、コメントのタイプミスや新しく導入された（または名前が変更された）メソッドの名前など、これを使用する小さな変更の種類がこれに該当することがよくあります。そうでない場合は、少なくとも候補コミットのリストが表示されます。

私はこれを毎日のワークフローで頻繁に使用して、以前に変更された行への小さな変更を作業中のブランチのコミットにすばやく統合します。スクリプトは見た目ほど美しくなく、zshで書かれていますが、書き直す必要性を感じたことがないので、十分にうまく機能してきました。

https://github.com/Valodim/git-fixup

このエイリアスを使用して、特定のファイルのフィックスアップを作成できます。

[alias]
...
# fixup for a file, using the commit where it was last modified
fixup-file = "!sh -c '\
        [ $(git diff          --numstat $1 | wc -l) -eq 1 ] && git add $1 && \
        [ $(git diff --cached --numstat $1 | wc -l) -eq 1 ] || (echo No changes staged. ; exit 1) && \
        COMMIT=$(git log -n 1 --pretty=format:"%H" $1) && \
            git commit --fixup=$COMMIT && \
            git rebase -i --autosquash $COMMIT~1' -"

でいくつかの変更を加えたmyfile.txtが、それらを新しいコミットに入れたくない場合は、最後に変更されたコミットのgit fixup-file myfile.txtを作成し、それからを行います。fixup!myfile.txtrebase --autosquash

commit --fixupそしてrebase --autosquash素晴らしいですが、彼らは十分に行いません。一連のコミットがA-B-Cあり、1つ以上の既存のコミットに属する変更を作業ツリーにさらに書き込んだ場合、手動で履歴を確認し、どのコミットに属する変更を決定し、ステージングして、fixup!コミット。しかし、gitはすでにすべてを私に代わって実行するのに十分な情報にアクセスできるので、私はそれだけを行うPerlスクリプトを作成しました。

git diffスクリプト内の各ハンクについてgit blame、関連する行に最後に触れたコミットを見つけるために使用しgit commit --fixup、適切なfixup!コミットを書き込むための呼び出しを行います。基本的に、以前手動で行っていたのと同じことを行います。

もしそれが便利だと思ったら、遠慮なくそれを改善し、繰り返してgitください。多分いつか私たちはそのような機能を適切に手に入れるでしょう。インタラクティブなリベースによって導入されたマージの競合を解決する方法を理解できるツールが欲しいです。

gcfフィックスアップコミットとリベースを自動的に実行するために呼び出される小さなシェル関数を作成しました。

$ git add -p

  ... select hunks for the patch with y/n ...

$ gcf <earlier_commit_id>

  That commits the fixup and does the rebase.  Done!  You can get back to coding.

たとえば、次のコマンドを使用して、最新の前の2番目のコミットにパッチを適用できます。 gcf HEAD~~

こちらが機能です。あなたはあなたにそれを貼り付けることができます~/.bashrc

git_commit_immediate_fixup() {
  local commit_to_amend="$1"
  if [ -z "$commit_to_amend" ]; then
    echo "You must provide a commit to fixup!"; return 1
  fi

  # Get a static commit ref in case the commit is something relative like HEAD~
  commit_to_amend="$(git rev-parse "${commit_to_amend}")" || return 2

  #echo ">> Committing"
  git commit --no-verify --fixup "${commit_to_amend}" || return 3

  #echo ">> Performing rebase"
  EDITOR=true git rebase --interactive --autosquash --autostash \
                --rebase-merges --no-fork-point "${commit_to_amend}~"
}

alias gcf='git_commit_immediate_fixup'

--autostash必要に応じて、コミットされていない変更を隠してポップするために使用します。

--autosquash--interactiveリベースが必要ですが、ダミーを使用して相互作用を回避しEDITORます。

--no-fork-pointまれな状況（新しいブランチから分岐していて、誰かがすでに過去のコミットをリベースしている場合）で、コミットが黙ってドロップされるのを防ぎます。

私は自動化された方法を認識していませんが、これは人間によるボット化を容易にする可能性のあるソリューションです：

git stash
# write the patch
git add -p <file>
git commit -m"whatever"   # message doesn't matter, will be replaced via 'fixup'
git rebase -i <bad-commit-id>~1
# now cut&paste the "whatever" line from the bottom to the second line
# (i.e. below <bad-commit>) and change its 'pick' into 'fixup'
# -> the fix commit will be merged into the <bad-commit> without changing the
# commit message
git stash pop

私はhttps://github.com/tummychow/git-absorbをお勧めします：

エレベーターピッチ

いくつかのコミットがある機能ブランチがあります。チームメイトがブランチをレビューし、いくつかのバグを指摘しました。バグの修正はありますが、アトミックコミットを信じているため、修正を示す不透明なコミットにそれらすべてを押し込みたくありません。のコミットSHAを手動で見つけるgit commit --fixupか、手動のインタラクティブリベースを実行する代わりに、次のようにします。

• git add $FILES_YOU_FIXED

• git absorb --and-rebase

• または： git rebase -i --autosquash master

git absorb変更しても安全なコミットと、それらの各コミットに属するインデックス付きの変更が自動的に識別されます。その後、フィックスアップを作成します！それらの変更のそれぞれに対してコミットします。信頼できない場合は、その出力を手動で確認し、修正プログラムをgitの組み込みの自動スカッシュ機能を使用して機能ブランチに折りたたむことができます。