Git - push just the last commit

Question

I have the following commits A->B->C->D. If i push D's SHA, i know that it will take also A,B,C along.

My requirement is a bash script that rebases the last commit and makes it first so it won't have any dependency.

So, A->B->C->D should become D->A->B->C so that i can use D's SHA in the push.

I've tried doing it multiple times, but i can't manage to get it done without breaking anything.

Have you done this before, or do you have any thoughts on how to do this in a bash script in order to be easily re-used?

Answer 1

There is no fully general solution to this, because comparing D with C will depend on what's in C, which in turn depends on what's in B, and so on. As a silly but simple example, suppose C-vs-D includes this change:

 The quick brown
-sheep
+foxes
 jump over the
 lazy dog.

But, in the version before version A, this reads:

 The quick brown
 sheep
 jumps over the
 lazy dog.

The correct adjustment is no doubt to make D use the singular, i.e., the change you want is now to replace sheep with fox (singular).

How will you automate the idea that the plural of sheep is sheep but the plural of fox is foxes, and the verb number (jumps vs jump) must match the noun?

That aside, in general, a rebase is simply a series of cherry-pick operations. To reproduce the A, then B, then C, then D sequence on some new base, you cherry-pick commit A (making a new commit, A'), then cherry-pick B onto A' making a B', then cherry-pick C onto B', and so on. To change the order, you simply change the order of cherry-picking operations.

Each commit can be labeled with a branch or tag name, so if you have this:

... - A - B - C - D   <-- yourbranch

we would want to do this—let's start by labeling the end of the ... sequence as commit o and call it start:

$ git branch start yourbranch~4

... - o                   <-- start
        \
          A - B - C - D   <-- yourbranch

Now we'll cherry-pick D onto a new branch tmp, which we create starting from commit o:

$ git checkout -b tmp start

... - o                   <-- start, tmp
        \
          A - B - C - D   <-- yourbranch

A successful cherry-pick creates new commit D':

$ git cherry-pick yourbranch

         D'               <-- tmp
        /
... - o                   <-- start
        \
          A - B - C - D   <-- yourbranch

Let's now cherry-pick A through C but add yet another branch label, tmp2:

$ git checkout -b tmp2
$ git cherry-pick yourbranch~4..yourbranch~1   # pick A-C all at once

             A'- B'- C'   <-- tmp2
           /
         D'               <-- tmp
        /
... - o                   <-- start
        \
          A - B - C - D   <-- yourbranch

Now we can delete the branch-name yourbranch entirely, making it look as though commits A through D are gone (they aren't, really, since git keeps things around for 30 days by default), and once we've done that we can rename tmp and/or tmp2.

Each cherry-pick can require manual intervention (manually fixing singular-vs-plural or whatever), so while you could automate some of this, you must be prepared to do something about failure. It's also odd (as noted in comments) that you should have to do this repeatedly: it suggests something is weird in your work-flow.