Partial content for undo-merge section

Author: ben

en/book/02-git-basics/chapter2.asc

@@ -626,10 +626,12 @@ image::images/18333fig0202-tn.png[The gitk history visualizer.]
 
 You can see the commit history in the top half of the window along with a nice ancestry graph. The diff viewer in the bottom half of the window shows you the changes introduced at any commit you click.
 
+[[_undoing]]
 === Undoing Things
 
 At any stage, you may want to undo something. Here, we’ll review a few basic tools for undoing changes that you’ve made. Be careful, because you can’t always undo some of these undos. This is one of the few areas in Git where you may lose some work if you do it wrong.
 
+[[_reset]]
 ==== Reset Demystified
 
 ===== The Three Trees

en/book/03-git-branching/chapter3.asc

@@ -396,10 +396,57 @@ You can modify that message with details about how you resolved the merge if you
 
 ==== Undoing Merges
 
-**TODO**
+Now that you know how to create a merge commit, you'll probably make some by mistake.
+One of the great things about working with Git is that it's okay to make mistakes, because it's possible (and in many cases easy) to fix them.
+
+Merge commits are no different.
+Let's say you started work on a topic branch, accidentally merged it into `master`, and now your commit history looks like this:
+
+.Accidental merge commit
+image::images/undomerge-start.png[Accidental merge commit.]
+
+There are two ways to approach this problem, depending on what your desired outcome is.
+
+===== Fix the refs
+
+If the unwanted merge commit only exists on your local repository, the solution is to move the branches so that they point where you want them to.
+In most cases, if you follow the errant `git merge` with `git reset --merge ORIG_HEAD`, this will reset the branch pointers so they look like this:
+
+.History after `git reset --merge`
+image::images/undomerge-reset.png[History after `git reset --merge`.]
+
+We covered `reset` back in <<_reset>>, so it shouldn't be too hard to figure out what's going on here.
+Here's a quick refresher: `reset --hard` usually goes through three steps:
+
+1. Move the ref that `HEAD` points to. In this case, we want to move `master` to where it was before the merge commit (`C4`)
+2. Make the index look like `HEAD`.
+3. Make the working directory look like the index.
+
+In the case of `--merge`, Git is extra careful with steps 2 and 3 to preserve any changes you've made in the working directory or the index, but otherwise works as though this were a `--hard` reset.
+
+The downside of this approach is that it's rewriting history, which can be prolematic with a shared repository.
+Check out <<_rebase_peril>> for more on what can happen, but if other people have the commits you're rewriting, you should probably avoid `reset`.
+
+===== Reverse the commit
+
+If moving the branch pointers around isn't going to work for you, Git gives you the option of making a new commit which undoes all the changes from an existing one.
+Git calls this operation a ``revert'', and in this particular scenario, you'd invoke it like this:
+
+[source,shell]
+----
+$ git revert -m 1
+----
+
+The `-m 1` flag tells Git which parent to keep.
+When you invoke a merge into `HEAD` (`git merge experiment`), the new commit has two parents: the first one is `HEAD` (`C4`), and the second is the tip of the branch being merged in (`C3`).
+In this case, we want to undo all the changes introduced by merging in parent #2 (`C3`), while keeping all the content from parent #1 (`C4`).
+
+The history with the revert commit looks like this:
+
+.History after `git revert -m 1`
+
+Take a look at <<_undoing>> for more information on Git's various methods of undoing things.
 
-- `git reset --merge ORIG_HEAD`
-- `git revert -m 1 sha`
 
 === Branch Management
 
@@ -618,9 +665,8 @@ In Git, there are two main ways to integrate changes from one branch into anothe
 
 ==== The Basic Rebase
 
-If you go back to an earlier example from <<_basic_merging>> (see <<rbdiag_a>>), you can see that you diverged your work and made commits on two different branches.
+If you go back to an earlier example from <<_basic_merging>>, you can see that you diverged your work and made commits on two different branches.
 
-[[rbdiag_a]]
 .Simple divergent history
 image::images/18333fig0327-tn.png[Simple divergent history.]
 
@@ -724,6 +770,7 @@ $ git branch -d server
 .Final commit history
 image::images/18333fig0335-tn.png[Final commit history.]
 
+[[_rebase_peril]]
 ==== The Perils of Rebasing
 
 Ahh, but the bliss of rebasing isn’t without its drawbacks, which can be summed up in a single line: