Duplicate commits after filter-branch to move root directory

Question

I am having a problem with my repository setup: I initialized my repository in the wrong directory and started using it. I already made some branches and merged them again. I would like to keep that history.

How it is now:

wrongRootProjectDir/
|
+-.git
|
+-realProjectDir
   |
   +-<Project files>

How it should look like:

realProjectDir
|
+-.git
|
+-<Project files>

So basically I would like to shift everything one directory up. wrongRootProjectDir also contains only the .git file and the realProjectDir directory.

I found some hints at SO How can I move a directory in a Git repo for all commits? that there could be a way. I run a git clone oldrepo newrepo to get a backup repo and ran

git filter-branch --subdirectory-filter realProjectDir -- --all

on the new repo. It seemed to work, however I have lost my merge and branch structure from the old repository. The filtered repo has the correct paths but is lacking the merge commits. Additionally the old commits are still around, so that the repo looks like this:

(Commit A)
|
(Commit B)
|
(Commit C)
|
(Commit A')
|
(Commit B')
|
(Commit C')

Where A' are the new commits. Is there a problem with my multiple branches and using filter-branches ? So right now I have each commit twice, once with the wrong old path and once with the new one.

Summary

Is there a way of moving a complete directory tree one layer upwards and keeping all branches and merges without generating double commits?

Update I still cannot manage to keep my merge commits and the right branch layout. Everything is flattened into a chain of commits.

Update

Added the history tree before:

and after running filter-branch using gitk:

The working directory is clean when I run this command. To test things I copied the whole directory tree using simple cp -r to another directory and tested it there. The filter-branch command works in that sense that it moves the subdirectory, but it still flattens the history. As far as I can see it, I have not done anything too complicated, just the normal branching and merging stuff.

Update

I showed the wrong picture for the before state. I tried to transform a non-rewritten repository.

Answer 1

filter-branch with a subdirectory filter is exactly the tool to do this. This is its entire purpose. If you're having problems, it's because you're doing something wrong that you haven't told us. filter-branch doesn't flatten history. It's possible that you're looking at gitk --all and seeing both the rewritten history and the old history (it'll be marked with original/refs/heads/...) - in that case, note that the two histories aren't connected. It's also possible that you did something to mess things up before the filter-branch. When you're trying again, are you doing it in a fresh clone, starting out from the exact original history you want?

Here's about the simplest possible example demonstrating that this works exactly as it should:

git init
mkdir subdir
touch x subdir/a subdir/b subdir/c
git add subdir/a
git commit -m 'a'
git add subdir/b
git commit -m 'b'
git checkout -b foo HEAD^
git add subdir/c
git commit -m 'c'
git checkout master
git merge foo
git add x
git commit -m 'x'
git filter-branch --subdirectory-filter subdir -- --all
# now inspect e.g. with gitk --all

The original refs are kept around in refs/original/refs/... so that if you screwed up, you can get back to them. If you inspect the results, and decide everything is good, then you can remove them. The method given in the manpage for that is this:

git for-each-ref --format="%(refname)" refs/original/ | xargs -n 1 git update-ref -d

though in practice you can also just do rm -rf .git/refs/original.

Answer 2

This should do it for you (change realProjectDir to whatever that folder is named):

git filter-branch --prune-empty --subdirectory-filter realProjectDir master

Reference