I think it should work to copy the directory to be renamed to a new directory with desired name, and delete the old directory, and git add
, git commit
and push
everything. But is this the best way?
1. Change a folder's name from oldfolder to newfolder
git mv oldfolder newfolder
2. If newfolder is already in your repository & you'd like to override it and use:- force
git mv -f oldfolder newfolder
Don't forget to add the changes to index & commit them after renaming with git mv.
3. Renaming foldername to folderName on case insensitive file systems
Simple renaming with a normal mv command(not git mv) won’t get recognized as a filechange from git. If you try it with the ‘git mv’ command like in the following line
git mv foldername folderName
If you’re using a case insensitive filesystem, e.g. you’re on a Mac and you didn’t configure it to be case sensitive, you’ll experience an error message like this one:
fatal: renaming ‘foldername’ failed: Invalid argument
And here is what you can do in order to make it work:-
git mv foldername tempname && git mv tempname folderName
This splits up the renaming process by renaming the folder at first to a completely different foldername. After renaming it to the different foldername the folder can finally be renamed to the new folderName. After those ‘git mv’s, again, do not forget to add and commit the changes. Though this is probably not a beautiful technique, it works perfectly fine. The filesystem will still not recognize a change of the letter cases, but git does due to renaming it to a new foldername, and that’s all we wanted :)
From Web Application I think you can't, but you can rename all the folders in Git Client, it will move your files in the new renamed folders, than commit and push to remote repository.
I had a very similar issue: I had to rename different folders from uppercase to lowercase (like Abc -> abc), I've renamed all the folders with a dummy name (like 'abc___') and than committed to remote repository, after that I renamed all the folders to the original name with the lowercase (like abc) and it took them!
I solved it in two steps. To rename folder using mv command you need rights to do so, if you don't have right you can follow these steps. Suppose you want to rename casesensitive to Casesensitive.
Step 1: Rename the folder (casesensitive) to something else from explorer. eg Rename casesensitive to folder1 commit this change.
Step 2: Rename this newly named folder(folder1) to the expected case sensitive name (Casesensitive ) eg. Rename folder1 to Casesensitive. Commit this change.
lots of correct answers, but as I landed here to copy & paste a folder rename with history, I found that this
git mv <old name> <new name>
will move the old folder (itself) to nest within the new folder
while
git mv <old name>/ <new name>
(note the '/') will move the nested content from the old folder to the new folder
both commands didn't copy along the history of nested files. I eventually renamed each nested folder individually ?
git mv <old name>/<nest-folder> <new name>/<nest-folder>
For case sensitive renaming, git mv somefolder someFolder
has worked for me before but didn't today for some reason. So as a workaround I created a new folder temp
, moved all the contents of somefolder
into temp
, deleted somefolder
, committed the temp
, then created someFolder
, moved all the contents of temp
into someFolder
, deleted temp
, committed and pushed someFolder
and it worked! Shows up as someFolder
in git.
Simply rename the folder. git is a "content-tracker", so the SHA1 hashes are the same and git knows, that you rename it. The only thing that changes is the tree-object.
rm <directory>
git add .
git commit
If you receive this error: fatal: renaming ‘foldername’ failed: Invalid argument
Try this:
git mv foldername tempname && git mv tempname folderName
git config core.ignorecase false; git mv foldername tempname; git mv tempname folderName
You can rename the directory using the file system. Then you can do git rm <old directory>
and git add <new directory>
(Help page). Then you can commit and push.
Git will detect that the contents are the same and that it's just a rename operation, and it'll appear as a rename entry in the history. You can check that this is the case before the commit using git status
Source: Stackoverflow.com