How To Undo A Git Rebase

Rebase is a Git utility that serves for integrating changes from 1 branch to another. Forth with git merge , it is the only change integration utility. While git merge is a forward-moving process, rebase provides powerful history rewriting features. In a fashion, we can understand rebase equally a merge with Git history.

That being said, it may happen that you accidentally performed the git rebase control on a local branch and pushed the changes to remote. So, which steps should you lot take to undo this activeness and resolve the problem? In today'southward article, our web evolution agency in Chicago explores means to undo rebase in Git. Nosotros'll besides talk almost mutual rebase employ cases and caveats, as well equally provide a detailed look at git rebase configuration and execution.

What is rebasing in Git?

Rebase is the process that allows you to move or combine a sequence of commits to a new base commit. In the context of a characteristic branching workflow, you can visualize the procedure, as shown in the figure below.

If we view this operation from a content perspective, we tin can say that rebasing is the activeness of changing the base of a branch from one commit to another. Developers use rebase to alter the starting point of a co-operative in commit history to the final commit of the main or whatever other co-operative. In layman'due south terms, rebase allows you to motion the starting point of your branch to another indicate.

Though, at first glance, it may seem that your co-operative looks the same, it is essential to note that it is actually made of entirely new commits applied to the specific base.

Use cases

Git rebase is nigh usually used to maintain a linear history of your project. Let's say that the primary branch of your project has farther progressed while y'all were working on your feature branch. At present, y'all wish to go those main branch updates to your feature branch and keep your co-operative's history clean, so you can later seamlessly merge information technology back into the master branch. By doing rebase, you lot'll get the same outcome equally if you lot were working off the latest chief branch.

To meliorate understand the benefits of keeping a clean branch history, imagine the post-obit state of affairs:

A bug appeared on the master branch that prevented a item feature from functioning as intended. You use the git log to cheque the history of the master co-operative. Since you and your squad followed the practise of keeping a make clean history, y'all'll have no bug understanding the data. If yous cannot place when the bug was introduced with the git log command, you'll probable execute git bifurcate . Due to the clean history, git bifurcate can work with a refined ready of commits and compare them to find the i that introduced the bug, giving you the chance to act accordingly and promptly.

At that place are two means to integrate your characteristic co-operative into the master co-operative:

• Merging straight
• Rebasing, so merging

While the outset selection requires a three-way merge and a merge commit, the 2d option produces a fast-forward merge and a linear history like in the diagram below.

Equally you can see, rebasing allows you to integrate upstream changes into your local repo easily.

Note : Information technology is imperative to mention that you should never rebase commits that have already been pushed to a public repository. That action would replace the old commits with new commits, and it would appear that a part of your project history has disappeared.

Dissimilar git rebase modes

There are two git rebase modes:

• Standard
• Interactive

Interactive git rebase is initiated using an — i argument that stands for interactive . Without this statement, the rebase process runs in standard mode. Let'southward employ an example to differentiate these two modes.

First, permit'southward say that nosotros take created a separate feature co-operative and checked out.

git checkout -b feature_branch principal

After editing some files, allow's commit changes.

Git commit -a -1000 "Adds new characteristic"

Standard rebase automatically applies your current working branch commits to the HEAD of the passed branch.

git rebase <base>

This control-line rebases the current co-operative onto the commit reference of your selection. That could exist an ID, a branch name, a tag, or a relative reference to HEAD.

By introducing the -i flag, you lot'll run an interactive rebasing process. Instead of moving all commits to the new base of operations, this procedure allows you to clean up your history by removing, splitting, or altering existing commits.

Git rebase — Interactive <base of operations>

You'll be presented with an editor, which you tin use to enter various commands in order to determine how and in which order individual commits will be moved to the new base of operations. In one case you lot accept all the actions specified, Git starts playing back commits and applying your commands. Here is a set of commands you cn apply during an interactive rebase:

• p (pick) – employ commit
• r (reword) – apply commit, but edit the commit message
• e (edit) – apply commit, but finish for amending
• s (squash) – use commit, just meld into the previous commit
• f (fixup) – similar to squash , but discard this commit log message
• ten (exec) – run control (the rest of the line) using vanquish
• d (drop) – remove commit

Besides the commands mentioned higher up, rebase provides boosted commands for yous to utilise in more circuitous situations. Here are some of those:

• git rebase — d – discards the commit from the concluding commit block during playback
• git rebase — p – leaves the commit unchanged as an individual commit in the branches history
• git rebase — x – executes a control shell script on each marked commit during playback (useful when running codebase's test suit on specific commits in order to identify regressions (bugs) during a rebase)

With the aid of interactive rebasing, you'll take full control over your projection'southward history. Developers find this way extremely useful since they tin can commit their history in the current country while they are preoccupied with coding and then become dorsum and clean it upwardly.

Interactive rebase allows you to smoothen your feature branch before merging information technology into the main codebase, which keeps the master branch history clean and meaningful.

How to disengage git rebase?

To undo git rebase, let's say we accept master and feature branches, each with the following chain of commits (we'll mark commit letters with C to brand things more simple and readable):

• Master: C4 – C2 – C1 – C0
• Feature: C5 – C3 – C2 – C1 – C0

If we use git log to wait at the prepare of commits in each branch, it may look something like this:

git log — oneline master

6a92e7a C4

259bf36 C2

f33ae68 C1

5043e79 C0

Git log — oneline characteristic

79768b8 C5

000f9ae C3

259bf36 C2

f33ae68 C1

5043e79 C0

What Git does during rebase is take each commit in one branch and try to replay the differences onto the other co-operative. Now. Allow'due south attempt to rebase the feature co-operative onto the main branch by taking C4 from the master branch and placing it onto the feature branch. This is what it may look like:

Git checkout feature

Git rebase master

First, rewinding head to replay your work on meridian of it…

Applying: C3

Applying: C5

One time this is done, your concatenation of commits should expect like the post-obit figure shows.

Let'southward apply git log again to see if we tin can spot any changes:

Git log — oneline master

6a92e7a C4

259bf36 C2

f33ae68 C1

5043e79 C0

Git log — oneline characteristic

c4533a5 C5

64f2047 C3

6a92e7a C4

259bf36 C2

f33ae68 C1

5043e79 C0

As y'all can see, our new C3 and C5 commits differ from the previous ones. They are really new commits created by making changes from the originals on height of the existing chain on the master co-operative. Let'southward proper name these new commits C3' and C5' . The original C3 and C5 commits however exist, but they no longer have a branch pointing to them.

The rebase is finished, and now we decided to use Git to disengage rebase. We can practise this past entering:

git reset 79768b8

With this command line, we have managed to undo rebase in Git, and our branch is one time once again pointing to the previous set of commits.

Luckily, we were able to call back what commit the branch used to signal to (C5), so it was easier for us to undo git rebase. Just, what happens if we cannot recall the commit in question? Fortunately, Git remembers the original commit for nigh operations that modify pointers similar rebase does. Information technology is saved in the .git repository and named ORIG_HEAD. Let'southward use the cat control to see the content of the file.

cat .git/ORIG_HEAD

79768b891f47ce06f13456a7e222536ee47ad2fe

If nosotros used git reset one time again, the log would show the following:

Git log — oneline characteristic

79768b8 C5

000f9ae C3

259bf36 C2

f33ae68 C1

5043e79 C0

We tin also use git reflog to observe this info. By using this command, we'll access a play-past-play listing of switches or changes to references in our local repository. Let's try it out:

git reflog

79768b8 HEAD@{0}: reset: moving to 79768b

c4533a5 Caput@{one}: rebase finished: returning to refs/heads/feature

c4533a5 HEAD@{2}: rebase C5

64f2047 Head@{iii}: rebase: C3

6a92e7a Head@{4}: rebase: checkout principal

79768b8 HEAD@{v}: checkout: moving from feature to feature

79768b8 Caput@{6}: commit: C5

000f9ae HEAD@{7}: checkout: moving from master to characteristic

6a92e7a HEAD@{8}: commit: C4

259bf36 Caput@{ix}: checkout: moving from feature to principal

000f9ae HEAD@{x}: commit: C3

259bf36 HEAD@{11}: checkout: moving from chief to feature

259bf36 HEAD@{12}: commit: C2

f33ae68 Head@{13}: commit: C1

5043e79 HEAD@{fourteen}: commit (initial): C0

Now that we have our listing of changes, we tin can reset to whatsoever of the items. All we demand to do is use the git reset command followed past the naming format from the log:

git reset Head@{1}

As you tin can run into, making changes in Git becomes much easier once you know that there is an accessible tape of the original chain of commits.

Git rebase caveats

While performing git rebase action, information technology is important to remember that merge conflicts may arise. That usually happens when you have worked on your feature branch for a significant amount of fourth dimension and diverged from the master branch also much. When you eventually effort to rebase, the master branch is likely to incorporate many new commits that may conflict with the changes on your co-operative. That can hands be avoided by ofttimes rebasing your feature branch against the chief co-operative and making more frequent commits. If you ever run across these conflicts, you can always add together the — continue or — abort command line arguments to git rebase in guild to advance or reset the process.

A more astringent caveat is lost commits from the interactive history rewriting process. Using subcommands such every bit squash and driblet will remove those commits from your branch's log. Though it may wait like the commits are gone for good, as we have previously mentioned, you tin can still discover them with git reflog , restore them, and disengage git rebase.

Final thoughts

Throughout this article, we have talked nigh the git rebase action. We have covered the common utilise cases, different rebase modes, and pitfalls, too as elaborated on how to undo git rebase in case anything unexpected happens.

The Git rebase process itself is neither complicated nor dangerous to perform. In fact, one of Git's master upsides is that it allows you to modify and try unlike things and rapidly disengage them if they don't work the way you expected. The main thing to avoid is to force push the results to a remote branch shared past other users during the history rewriting interactive rebase. That mode, y'all can overwrite other remote users' piece of work when they try to pull changes.

Schedule a call to go far bear on with our team, or visit our web log pages to observe more than articles about Git, as well as check other interesting info, such as our take on the reason why you should switch to custom-coded websites .

Source: https://alphaefficiency.com/git-undo-rebase

Share this post