how to rebase backwards

I want to rebase a new branch onto an earlier commit 

original:  
E is a newly created branch from D and not yet modified
                    E
                   /
-- A -- B -- C -- D

new: what I wanted
     B'-- C' -- E     for deployment
    /          
-- A -- B -- C -- D    trunk

so that I can continue to change all commits from B to C without affecting E

I try (not sure if correct) doing it by
  git rebase --onto A B E

but then there is a lot of conflict/both modified files. What will be the correct way to do it?

bill lam <cbill.lam@gmail.com> writes:

I sense a grave misconception here. If you have "not yet modified" anything at all since D, then E does *not* even exist.

Remember, a branch is just a pointer pointing at a commit. You can have more than one such pointers pointing at the same commit. So, if you have been working on 'master' branch, building up to D, your history would look like this:

    ---A---B---C---D
                   ^ master

And you would "create a branch", say "hack", like this:

    $ git checkout -b hack

What happens to your history when you do so is this:

                   v hack
    ---A---B---C---D
                   ^ master

The same commit "D", pointed by two branches, 'master' and 'hack'.

If you start editing files at this point, before making a commit, nothing in the history changes. But once you make a commit E while on branch 'hack' (since you ran "git checkout -b hack" above), the history changes into this:

                     E
                    /^ hack
    ---A---B---C---D
                   ^ master

This asks to replay C, D and E in this order on top of A, to create

      C'--D'--E'
     /
 -- A

which is different from what you described earlier.

Assuming that you did actually commit to create E, after branching 'hack' off of 'master', i.e. your history looks like this:

                     E
                    /^ hack
    ---A---B---C---D
                   ^ master

the way to create what you want would actually be

    $ git checkout -b deploy master^ ;# branch deploy at "C"
    $ git cherry-pick hack           ;# replay E on top of it

which would make a history of this shape.

                 v deploy
                 E'  E
                /   /^ hack
    ---A---B---C---D
                   ^ master

If you need to later tweak B and C (only) for deployment branch, you could further rewrite B and/or C with

    $ git rebase -i A

to rewrite everything since A leading to the tip of your current branch (i.e. E'), to result in

                   v deploy
           B'--C'--E"
          /
         /       E'  E
        /       /   /^ hack
    ---A---B---C---D
                   ^ master

Now, you may not want to keep both 'hack' and 'deploy'. Perhaps you forked 'deploy' and modified for E but it was done on top of D that you did not want to include in 'deploy' by mistake. IOW, you might have done this:

                     E
                    /^ deploy
    ---A---B---C---D
                   ^ master

Another way to make 'deploy' point at the result of replaying E on top of C when your history looks like this is (assuming you are on 'deploy'):

    $ git reset --hard HEAD^^ ;# reset to "C"
    $ git cherry-pick @{1}    ;# cherry-pick "E"

That would give you a history of this shape:

                 v deploy
                 E'  E
                /   /
    ---A---B---C---D
                   ^ master

Note that the original commit "E" becomes dangling and it will eventually be garbage-collected.

Thank you for detail explanation.  From what you described, I begin
with master commit D, 
 $ git checkout -b deploy
 $ git commit --allow-empty -m deploy

 
                      E
                     /^ deploy
     ---A---B---C---D
                    ^ master
 
 $ git rebase -i A

                      v deploy
          B'--C'--D'--E'
         /
     ---A---B---C---D
                    ^ master

since E is an empty commit, I suppose content of D' E' and D are identical at this point. Is that correct?

If several months later, I forget which is the common ancestor for master and deploy, how do I generate the above graph or identify commit A as the common ancestor for these two branches?

bill lam <cbill.lam@gmail.com> writes:

But why on earth would you want to use --allow-empty? There is no reason for that. Just let deploy be where it is when you created it (until you actually add something to it).

Assuming you didn't intentionally change it during rebase, yes.

That is exactly what git does all the time. You can use many command. For instance git log --graph master...deply whill show you both branches, starting from their common ancestor. "git merge-base deploy master" will tell you that the common ancestor is. Etc.

On Thu, 05 Nov 2009, David Kågedal wrote:

David, thank you for this info.