Sane way to roll git master branch back in time + and then merge some files from a branch based on current master?

Question

(I'm afraid my search-fu is lacking, I didn't find answers to this specific scenario)

So, I have a git repo that looks like this:

   A a'', b''
   |
  /
 M a',b'
 |
 |
 |
 o a, b
 |

M is a current master, and A is a topic branch. o is an old commit, a,b, etc refer to the states of two particular set of files in the repo.

I've realized that I want to move master back in time to the commit o (files a), except for some particular files (b'') created / modified in topic branch A. In other words, I want the new master to look like this:

M' a, b''
|

What would be the best way to do this?

(The one option I could do would be copy the files b to somewhere outside of the repo, roll the master back in time, and then just re-add those files like they were totally new commits. However, that doesn't sound like a very 'git' way of doing things.)

I also have an remote repo. I can rebase and push --force things, but I'd rather not; while not critical, I'd like the history to look 'nice' and pullable.

Answer 1

First, it's generally bad to change history on a "published" branch such as master. Second, you're not working with file-sets, but change sets. Instead of changing history, you can revert all the commits between 'o' and 'M', and then copy the contents of b'' over to your "clean" master.

Answer 2

Checkout the commit you want to base things on:

git checkout desired-master

Create a new branch:

git checkout -b files-to-save

Bring across the state of those files from the undesirable master:

git checkout master path/to/file/a
git checkout master path/to/file/b

Commit those changes, and then rebase them onto the desired master.

git rebase desired-master files-to-save

You will have to force push to achieve the "clean" history that you want for the master branch. This is not usually desirable but is possible - you'll need to communicate this before you do it to everyone else on the team, and you may need to make changes to your CI tool if you're using one.

Answer 3

Without changing the history of master

From your current master, get back the version you wish for file a :

git checkout o -- a # 'o' is the commit reference, 'a' is the filename

Commit this :

git add a
git commit -m 'reverting file a to a previous correct version'

Get the version you wish for file b, from branch A :

git checkout A -- b
git add b
git commit -m 'integrating changes from branch A on file b'

Changing the history of master

For some reason, you may wish to 'erase' the erroneous history between o and master.

First : be safe and keep a reference to your current master :

git branch backup/master master

This will create a new branch backup/master, which points to the same commit as your current master.

If you have some modified files, store the changes somehow : aither git stash (quick to run, but easy to forget) or add the changes and commit them to backup/master (more visible in your history).

From your master branch, roll back to the commit o :

git checkout master # just to be sure you are acting on master
git reset --hard o # warning : if you have modified files, this is one of
                   # the few git commands which will throw away the
                   # changes with no way to get them back

Get the modifications you wish from A :

git checkout A -- b
git add b
git commit -m 'integrating changes from branch A on file b'

Keeping the history from A

Instead of just running git checkout A -- b (get the file's exact content, but do not keep the history), to can use git rebase to keep a track of the history master--A :

git checkout A
git branch backup/A # keep an easy way to undo your changes !
git rebase master