从先前的提交中获取Git分支并从主服务器中提取更改

Question

Let's say I have made following commits. All commits were in the same branch. In Commit 3, I deleted C and now I need to add C back to the current

Commit 1: A,
Commit 2: A, C 
Commit 3: A, 
.
.
.
Master (current) : A, B, D

And now, I want to create a branch with A, B, C, and D. This is what I have tried.

1. create a local and remote branch at commit 2

   git checkout branch mybranch hashtag-of-commit2

2. pull changes from origin/master (current) to add B and D

   git checkout mybranch

   git fetch origin

   git merge origin/master

Doing this, it deletes C and adds B and D. The final result is A, B, D. What I'd like to have is A, B, C and D. How do I this?

Answer 1

Here's what I think the question means, in more traditional layout, changing letters for numbers and numbers for letters.

The log (single branch) looks like this

---A---B---C---D--- .... ---- HEAD master
       +x  -x

Commit B adds x and commit C reverts that change. OP wants to add x back in.

Assuming you are on master (ie already have the changes introduced by commits D .. master ), prima facie git revert sha-1-of-C should do that, ie you are reverting the commit that reverted the original change.

I don't see what this has to do with a remote branch.

Answer 2

A whole git revert would also revert the changes to A introduced in Commit3 , so that's not what you want.

To restore file C as present in Commit2 , you have not only one option:

1. Simply show the state of C

git show shows the content of a file in a certain revision. So

git show Commit2:C > /path/to/C  

will print the content of file C and will store it in /path/to/C . We still need to add it again to the index:

git add /path/to/C && git commit -m "restoring C"

2. Partially revert the commit

We know that C was changed in Commit3 in a way we don't want. To create a patch from the changes introduced in Commit3 to C (ie it's deletion), we could use git diff :

git diff Commit3~..Commit3 -- /original/path/to/C > c-changes.patch  

Now, c-changes.diff holds the changes introduced. Now, we apply this patch in reverse order and restore C :

git apply --reverse c-changes.patch  

C is restored, re-add it to the index:

git add /path/to/C && git commit -m "restoring C"

3. Rebase away the deletion

When you use the previous option, Commit3 still removes C and you have an extra commit restoring C . If you haven't pushed anywhere since Commit3 , we could edit Commit3 so that it does no longer delete C . First, create the patch as described in option 2. Then, invoke an interactive git rebase :

git rebase -i Commit2

This will bring up a dialog in your $EDITOR . You'll see Commit3 . Choose to e dit the commit, save the file and close the file. Then, the rebasing will start and it will stop right after Commit3 was applied. Now take your patch and apply it in reverse order:

git apply --reverse c-changes.patch

The patch was applied, now we amend the last commit and delete the deletion of C from history:

git add /path/to/C && git commit --amend -C HEAD && git rebase --continue  

Rebasing continues after this and once it's finished, you have a fresh history where C was never gone.