How can I move all git content one-level up in the folder hierarchy?

I have a git repository whose structure looks like:

+--repo.git
|
+----+bootstrap.py
+----+buildout.cfg
+----+.gitignore
+----+webapp
|
+---------+manage.py
+---------+modules
+---------+templates
+---------+static
+---------+...
+---------+...

I would like to move the contents of the webapp folder one level up. My resulting repo should look like:

+--repo.git
|
+----+bootstrap.py
+----+buildout.cfg
+----+.gitignore
+----+manage.py
+----+modules
+----+templates
+----+static
+----+...
+----+...

Can I do this by simply moving all the files of the webapp directory one level up, deleting the empty webapp directory and then committing the changes? Would this preserve the commit history of the files under the webapp directory?

Although a very simple question for many of you, I'd like to be sure. The last thing I'd want is a git soup.

---

I tried moving the files but I lost the commit history as git doesn't really handle a move or a rename. I do know that even though it shows up as a new file in the logs, it is still possible to view the commit history for the file using some options in git log.

From what I've read, the best way to accomplish this would be using git-filter. I'm not very good with shell or git so could someone tell me what I'd need to execute to do the aforementioned.

The right way to do this is:

git mv repo.git/webapp/* repo.git/.
git rm repo.git/webapp
git add * 
git commit -m "Folders moved out of webapp directory :-)"

Another variant of Sumeet's answer - in the repository directory above "webapp" execute following command:

git mv webapp/* ./ -k

-k - Skip move or rename actions which would lead to an error condition, otherwise you get:

fatal: not under version control, source=webapp/somefile, destination=somefile

I was able to get it to work simply by doing this from the destination folder:

git mv webapp/* .

In Windows shell the * will not work (fails with an error Bad source), but it will work in Windows if you use the Git Bash shell, which expands the * wildcard.

If you are using Powershell, you can also do:

git mv (gci webapp/*) .

or

git mv (get-childItem webapp/*) .

in windows you can do the below:

While you are in the child folder

for /f %f in ('dir /b') do git mv %f ../

The result all objects in child folder will be in the parent folder

Please note: some errors may raise when you have object in the child folder with name equals to the child folder

The solution you mentioned should work, as git tracks changes based on the hash of the files first and then their location.

This wont work if as part of moving the file, you change the contents of the files.

Bottom case, try it, and if it doesn't work, you can revert the changes, before pushing the changes to the master repo :). This is one of the reasons why I really like git.

Edit

I forgot to mention that to see the changes after a rename, you need to use the '--follow' parameter. Check this example

First, I created a new git repo

94:workspace augusto$ mkdir gittest
94:workspace augusto$ cd gittest/
94:gittest augusto$ git init
Initialized empty Git repository in /Volumes/Data/dev/workspace/gittest/.git/

Then created a file in folder/test

94:gittest augusto$ mkdir folder
94:gittest augusto$ vi folder/test
94:gittest augusto$ git add folder/test
94:gittest augusto$ git commit -am "added file"
[master (root-commit) 7128f82] added file
 1 files changed, 1 insertions(+), 0 deletions(-)
 create mode 100644 folder/test

Then moved the file to newfolder/test

94:gittest augusto$ mkdir newfolder
94:gittest augusto$ mv folder/test newfolder/
94:gittest augusto$ git add newfolder/test 
94:gittest augusto$ git commit -am "moved/renamed file"
[master 4da41f5] moved/renamed file
 1 files changed, 0 insertions(+), 0 deletions(-)
 rename {folder => newfolder}/test (100%)

And git log --follow newfolder/test shows the full history (I've added the parameter -p to show more information, such as the path).

94:gittest augusto$ git log --follow -p newfolder/test 
commit 4da41f5868ab12146e11820d9813e5a2ac29a591
Author: Augusto Rodriguez <xxxx@gmail.com>
Date:   Sat Aug 20 18:20:37 2011 +0100

    moved/renamed file

diff --git a/folder/test b/newfolder/test
similarity index 100%
rename from folder/test
rename to newfolder/test

commit 7128f8232be45fd76616f88d7e164a840e1917d5
Author: Augusto Rodriguez <xxxx@gmail.com>
Date:   Sat Aug 20 18:19:58 2011 +0100

    added file

diff --git a/folder/test b/folder/test
new file mode 100644
index 0000000..3b2aed8
--- /dev/null
+++ b/folder/test
@@ -0,0 +1 @@
+this is a new file

I hope this helps!

If you are using PowerShell you can run this command from your project root and it will place the content of webapp there.

Get-ChildItem .\webapp\ | ForEach-Object { git mv $_.FullName .\ }

Yes you can simply move the files over. However you do need to tell git that the old files in the webapp folder have gone, that is, git needs to update its index of finished/committed files.

So you can use git add -A . to make git notice all the changes, or use the git mv <files> to tell git to do the move itself. See the git mv man page.

--update.

You noted that you thought ".. git doesn't really handle a move or a rename.." - I was also confused at first and hadn't fully understood the way the Index works. On the one hand folk say git only takes snapshots and doesn't track renames, but then you get hit with it 'failing' if you update .gitignore, or mv a file, etc. This 'failure' is a confusion about how the Index works.

My visualisation is that the Index/Staging area is a place, like a storyboard wall, where you place a copy of your latest and greatest 'finished' file, including its path, (using git add), and it is that copy that is committed. If you don't take that copy down from the storyboard wall (i.e. git rm), then git will continue to commit it, and confusion abounds (see many SO questions...). The Index is also used by git during merges in a similar manner

In Windows , using Bash , following worked:

git mv /c/REPO_FOLDER/X_FOLDER/Y_FOLDER/Z_FOLDER/* /c/REPO_FOLDER/X_FOLDER/Y_FOLDER

Yes, git will track the changes in past content. It uses hashes of the file's content so regardless of where they are located in the directory structure, they will be the same file.

As a result, you should do the move in one commit, and then fix up any edits in a subsequent commit. That will enable Git to determine the redirection with maximum efficiency, and won't make any difference to the amount of data stored in the repository (since you'd be making those changes anyway).