Will rebase single commit pointed by HEAD to master and end up in 'detached HEAD'. Git rebase -onto master HEAD~ HEAD # Expanded. This way you can limit number of rebase commits by taking the latest ones and leaving primary diverged commits. So practicaly it can be any other commit or branch. The master in -onto is taken from 1st git rebase argument. What is interesting when 2nd argument is commit hash instead branch name rebase still works but there is no branch to move so you end up in 'detached HEAD' instead being checked out to moved branch. You won't notice that after rebase git moves branch to most recently rebased commit and does git checkout branch (see git reflog history). When used in standard way, like: git checkout branch Git rebase -onto master master current_branch

git rebase masterĮxpands to either : git rebase -onto master master HEAD Further explanation and applicable usage of git rebase -onto. This is because the range of commits will be some commits which are already in that branch and during rebase all of them will be skipped. The command is nonsense in any case where branch name is repeated like that. The commit is skipped because it is already applied to -onto target B and so nothing happens. If you add -i flag you will see it is single commit pointed by HEAD. The questions is what 'some commits' are. What looks like error here is placement of B which means 'move some commits which lead to branch B on top of B'. OP case o-o (A)Ĭan be changed to single command: git rebase -onto B A B branch to let git find the 1st diverged commit from branch i.e. It's exclusive because it's easier to specify 1st commit by typing e.g. Means rebase commits in range (D, H] on top of F.

Which is the same as (because -onto takes one argument): git rebase D H -onto F Put shortly, given: Before rebase After rebase The trick here is remembering that the commit referenced by is included in the range and will become the new HEAD after the rebase is complete. The syntax of git rebase -onto with a range of commits then becomes git rebase -onto. Rebase the range of commits whose parent is D up to H on top of F. We can do that by saying git rebase -onto F D H, which means: In this case, we want to rebase the exact range E-H on top of F, ignoring where HEAD is currently pointing to. In fact, it allows you to rebase an arbitrary range of commits on top of another one. Git rebase -onto can go one step further in terms of precision. The Surgeon: git rebase -onto with 3 arguments

In this example, in order to remove C and E from the sequence you would say git rebase -onto B E, or rebase HEAD on top of B where the old parent was E. Īnother scenario where this comes in handy is when you want to quickly remove some commits from the current branch without having to do an interactive rebase: Before AfterĪ-B-C-E-F (HEAD) A-B-F (HEAD) The syntax of git rebase -onto is then git rebase -onto. In other words, change the parent of E from D to F. Rebase the commit reachable from HEAD whose parent is D on top of F. In this case, we would say git rebase -onto F D. We're only interested in bringing F into our working branch while, at the same time, we don't want to keep D because it contains some incompatible changes. This is for scenarios where you need to be precise.įor example, let's imagine that we need to rebase HEAD precisely on top of F starting from E. It grants you exact control over what is being rebased and where. Git rebase -onto allows you to rebase starting from a specific commit. The Precise: git rebase -onto with 2 arguments

change its parent) on top of the latest commit reachable from branch but not from HEAD, that is G. Saying git rebase branch will take D, that is the first commit after the branching point, and rebase it (i.e. In this example, F and G are commits that are reachable from branch but not from HEAD. Before AfterĪ-B-C-F-G (branch) A-B-C-F-G (branch) This is the most common case of rebasing and arguably the one that requires less planning up front. Git rebase is going to rebase the branch you currently have checked out, referenced by HEAD, on top of the latest commit that is reachable from but not from HEAD. If you're interested in the difference between git rebase and git rebase -onto read on. Or rebase B on top of A starting from the commit that is the parent of B referenced with B^ or B~1. The correct syntax to rebase B on top of A using git rebase -onto in your case is: git checkout B