How do I commit case-sensitive only filename changes in Git?

Question

I have changed a few files name by de-capitalize the first letter, as in Name.jpg to name.jpg. Git does not recognize this changes and I had to delete the files and upload them again. Is there a way that Git can be case-sensitive when checking for changes in file names? I have not made any changes to the file itself.

Magdala

@nif this isn't quite correct, Git actually has a configuration setting that controls whether or not it ignores case sensitivity. – Sprinkle

See https://mcmap.net/q/45668/-how-do-you-change-the-capitalization-of-filenames-in-git: since git 2.0.1, a simple git mv works. – Edholm

possible duplicate of Git: Changing capitalization of filenames – Acaricide

@nif Just wanted to add (a few years later ;) that HFS can be made case sensitive, but it's not case sensitive by default. I have a separate 65 GiB partition formatted with case sensitive HFS, which I use for my git working copies. Spares a lot of my sanity, I must admit... – Couthie

Answer 1

As long as you're just renaming a file, and not a folder, you can just use git mv:

git mv -f yOuRfIlEnAmE yourfilename

(As of a change in Git 2.0.1, the -f flag in the incantation above is superfluous, but it was needed in older Git versions.)

Telegenic

this gives me 'source directory is empty' while it is not – Looney

Tried that and got fatal: renaming '...' failed: File exists. I'm doing that in Ubuntu virtual machine, which runs in OSX – Asterism

Using MacOS here (case-insensitive FS) and -f worked! Thanks for the tip – Pious

@Looney if you have spaces in the file path, trying wrapping it in quotes. – Tympanitis

Don't forget to give the full file path. Obvious, I know, but got me for a while – Vicinage

As WiseStrawberry pointed out, this may give a "source directory is empty" error when applied to folders in the root git directory. (subfolders seem to work fine) – Lepidopteran

This isn't working for me on a directory i want to rename (failed: Invalid argument) with full file path and without. weird. – Kuntz

You can't move directories with git mv. You'll need to do each file in the directory if you are trying to modify the case of a directory name. – Oestriol

Strangely enough, to get this to work on Mac OS, I first had to rename a given file 'TestCase.ts' to 'TestcaseSomething.ts', commit it, then correct it to the desired result 'Testcase.ts' before a final commit and push. – Trabeated

To the top voted comment: you do need the -f switch with the latest git (2.18) otherwise you could get the fatal: destination exists error. – Duke

git mv -f {O,o}ldFileNameCase – Preceding

If I do this I can see the file has been removed from Git but it doesn't track the new file. – Pondweed

Worked perfectly on Mac OS Catalina with git 2.24.0 – Kloof

It's important to note that this doesn't work if you're trying to rename a directory instead of a file. If you need to rename a directory, you have to do a git mv for each file in the directory instead. – Thamos

FYI: I am on git 2.29.2, running on macOS, and it still requires the -f to do a case sensitive file rename – Nettie

This worked, but note that it might not show up properly immediately. For me it did not show up correctly in GitKraken on Windows, but did show up after pushing the commit to the remote repository and viewing with a Git client, and it did show up when viewing the commit with GitKraken on a case-sensitive platform (Linux). – Sylvan

Some issue are like Eternal Pandemic. They affect the world for ever, lol. Worked for me on moving a Signin.js to SignIn.js. – Crites

Thank you! We had a file that was committed and accidentally changed to uppercase. Windows, being case insensitive, wasn't able to pull both files down, so I couldn't delete the other one or anything like that. 'moving' the file in this way worked. This saved a lot of time. – Athalla

If you're seeing failed: Invalid argument when trying to rename a directory then rather than renaming each file, running the git mv -f command twice was faster for me. Example: git mv -f Oldname _Oldname && giit mv -f _Oldname newname (you have to change more than just the case for it to run) – Relucent

Now, it is year 2023, and I'm using git git version 2.40.0.windows.1, and I have already run the command git config --local core.ignorecase false, but I still need the --force option. If not, I got the fatal: destination exists error. – Koala

Answer 2

Git has a configuration setting that tells it whether to expect a case-sensitive or insensitive file system: core.ignorecase. To tell Git to be case-senstive, simply set this setting to false. (Be careful if you have already pushed the files, then you should first move them given the other answers).

git config core.ignorecase false

Note that setting this option to false on a case-insensitive file system is generally a bad idea. Doing so will lead to weird errors. For example, renaming a file in a way that only changes letter case will cause git to report spurious conflicts or create duplicate files_{(from Mark Amery's comment)}.

Documentation

From the git config documentation:

core.ignorecase

If true, this option enables various workarounds to enable git to work better on filesystems that are not case sensitive, like FAT. For example, if a directory listing finds makefile when git expects Makefile, git will assume it is really the same file, and continue to remember it as Makefile.

The default is false, except git-clone(1) or git-init(1) will probe and set core.ignorecase true if appropriate when the repository is created.

Case-insensitive file-systems

The two most popular operating systems that have case-insensitive file systems that I know of are

• Windows
• OS X

Sprinkle

This is a good answer and worked for me, but be careful when doing this because it changes your production environment. So consider this change carefully before making it. – Greeting

Turns out this was enabled by default in a project. Sure made life interesting for a bit. – Sykes

Looks like you have to do it for every git repository you have. How to set it global? – Confederate

On a side note, I don't think that Mac OS X itself is case-insensitive. Instead, it's the filesystem that determines case-sensitivity. When formatting a HFS+ partition, users can choose whether to make it case-sensitive or insensitive. Case case-insensitive is the default. – Lenna

It seems very worth noting in this answer that setting this option to false on a case-insensitive file system is a bad idea. This isn't necessarily obvious. For example, I just tried this on my Mac, thinking it would fix my problems, then renamed a file from productPageCtrl.js to ProductPageCtrl.js. git status saw a new file called ProductPageCtrl.js but didn't think that productPageCtrl.js had been deleted. When I added the new files, committed, and pushed to GitHub, the GitHub repo now contained both files even though my (supposedly up to date) local repo had only one. – Devoir

@MarkAmery That sounds a lot like a bug in your Git client. Did you file a report? – Tubulate

This worked perfectly for my situation. I had renamed three classes within Visual Studio, and knew that the name change had taken place in the file system, but didn't notice that the change had not taken place in git until I had created a pull request and the files still had the same missing case issue that they had before. – Flotilla

@Tubulate this is not a bug, this is expected behavior. It is in fact a bad idea to set this to false on an insensitive filesystem because this is what happens. The reason why git didn't saw the lower-case file been deleted is that the filesystem doesn't report it as deleted as it does ignore the case while git does not with this option set to false. Its not that the filenames don't have lower vs upper case on ntfs or fat its just that filename lookup is ignoring the case. – Christabella

@Christabella From a user perspective, it still feels a lot like an immaturity, since you would hope that your Git client is smart enough to take care of this. But then again, Linux is not known for trying to make things user-friendly, but robust :) – Tubulate

@Tubulate git is smart enough. Thats why you should not set this to false on a case insensitive file system. Use git mv to move the file and see how git manages it. If you move the file without git, there is nothing git can do as the filesystem isn't telling the truth to git. This is an issue of ntfs/fat/hfs and thelike and not git/linux. – Christabella

This works on local git repo, but doesn't seem to have effect after pushing – Clere

@Mark Amery I have comfired that git config core.ignorecase false is useless on mac.I have to wrap git push/pull/checkout/status with another tool to workaround this git bug. – Colcothar

@Christabella this does seem like a bug to me if it behaves this way. It is easy enough to pass the flag FILE_FLAG_POSIX_SEMANTICS to the method to verify the file exists using its case sensitive name. The file WON'T be found if this flag is set. Also for find file you can use FileFirstFileEx with FIND_FIRST_EX_CASE_SENSITIVE. References: mathematica.stackexchange.com/questions/97734/… msdn.microsoft.com/en-us/library/windows/desktop/… – Vanquish

Worked great for me on Windows 10, GitKraken client. – Overdye

Post should be edited to include various warning mentioned here. I wasted a lot of time because of this. – Pteranodon

Using case-insensitive fs/os for dealing with case-sensitive filenames is a bug in your workflow. – Osmunda

Running $>git config core.ignorecase will give you the current setting. In my case it was true. Hence my file name extension case changes were not getting identified. Running $> git config core.ignorecase false has done the trick and worked like a charm. Note that I had to restart the Visual Studio 2017. – Samirasamisen

does the OP mean macOS or OSX? – Jehoshaphat

@MarkAmery's comment is from 2015. What he describes (keeping old file) is not happening anymore. – Nightmare

@Nightmare it's still happening with git 2.29.2 – Coolidge

Add the global flag via: git config --global core.ignorecase false – Emmieemmit

Worked on MacOs, however it should be noted that this created duplicate files. – Fibroma

@MarkAmery: Your comment is a valuable warning, I took the liberty of adding it to the answer. – Honourable

@Honourable Hmm. I won't remove it the warning, but on further reflection since I left that comment I think the real problem is that this answer is just fundamentally wrong. This question is all about case-insensitive file systems (since on case-sensitive ones you can handle a case change like any other rename), and since setting ignorecase to false on a case-insensitive file system breaks stuff and doesn't help at all, it seems to me that this answer is just plain never useful in any circumstances. [1/2] – Devoir

[2/2] Thus it seems to me that the edited-in warning kind of torpedoes the entire answer - it amounts to a warning saying "by the way, this answer is wrong and you should ignore it". I've got mixed feelings about such warnings. Really, I think what this answer needs is to be heavily downvoted - but, frustratingly, only a small fraction of the over 250 upvoters on my comment pointing out the answer's problems have downvoted the answer. I'm not sure what the best way to proceed is. ¯\_(ツ)_/¯ – Devoir

@MarkAmery: Yes, the problem is quite tricky, and it seems there are problems with all possible solutions - case-insensitive FS just suck :-/. Maybe I can think of a better edit later. – Honourable

To RENAME/RE-CASE a directory, you should git mv subjectdirectory tmp then git mv tmp SubjectDirectory. That will avoid the problem that @Mark Amery experienced. – Emmieemmit

Turning on case sensitivity would be good, if there were not so many bugs in git management tools. At least on Windows. – Diaspore

! Be careful using this setting in a case insensitive OS. I recommend using this setting only temporarily if you don't remember the files that were renamed. 1) Use git config core.ignorecase false 2) Check with git status and take a note of the files and folders with a change 3) Set the setting to the previous default value with git config core.ignorecase true 4) Use git mv -f filename FileName where necessary – Benares

Answer 3

Fix git filename case on whole repo:

(replace . with (sub-)folder name for just part of the repo)

git rm -r --cached .
git add --all .

git status ##Review that **only** changes staged are renames

## Commit your changes after reviewing:
git commit -a -m "Fixing file name casing"
git push origin main

Explanation from @Uriahs Victor comment:

What this command actually does is deletes the cached version of the file/folder names that git thought still existed. So it will clear its cache but leave everything in the current folder (where you've made your changes locally) but it will see that those other wrong case folders/files do not exist anymore so will show them as deleted in git status. Then you can push up to GitHub and it will remove the folders/files with wrong cases. This answer has a graphic depicting what the command means.

Caveats

• This removes files that were .gitignore'd, but force-added inside an ignored folder, e.g. git add -f ignored/folder/force-added.file. Simply revert the deletion with

  git checkout HEAD -- ignored/folder/force-added.file
  

• This removes explicit git file permissions (git update-index --chmod=...) from files, e.g. gradlew. Either re-apply the permissions manually until the file is no longer showing as "modified" in git status; or reset the file to what's in the repo:

  git checkout HEAD -- path/to/file/with/executable-bit.set
  

• For submodules we can get "You've added another git repository inside your current repository." warning, in that case do what it says:

  git rm --cached submodule/path
  git submodule add <url-of-submodule-remote> submodule/path
  

Ticonderoga

This is the solution. And unlike the other answers it works well when you are doing batch renames. On glamourphilly.org we needed to change every .Jpg to .jpg. In Finder you can do batch renames like that and this answer lets you check it in. – Condense

This was the only easy solution for me too – Russian

This is the easiest solution by far. Works for files and directories. Thanks! – Siesta

OMG THANK YOUUUU I was ready to pull out my hair as to why i have two cases of the same folders on github even though locally I only had one case! this was frustrating thank you – Diverticulosis

What this command actually does is deletes the cached version of the file/folder names that git thought still existed. So it will clear its cache but leave everything in the current folder (where you've made your changes locally) but it will see that those other wrong case folders/files do not exist anymore so will show them as deleted in git status. Then you can push up to github and it will remove the folders/files with wrong cases. This answer has a graphic depicting what the command means: https://mcmap.net/q/45669/-clear-git-local-cache – Diverticulosis

POV: The best answer has only 70 upvotes – Bakker

someone give this man a raise! – Kapok

This is the easiest way to handle case changes in many filenames in a repository. I had to do this when I changed the case of many names in a large repo after setting git config core.ignorecase false. Although the case changes appeared in my local repo, on pushing to GitHub the pre-case-changed files appeared alongside their case-changed twins. These steps fixed the issue on GitHub. – Monosymmetric

Upvoting so this can gain more reach, this works flawlessly as I recently restructure my code and the inconsistent naming make me have to rename lots of files/dir as to adhere to the style rule. – Oleary

This is AMAZING. Another huge benefit is that it creates a deletion commit for files that have since been .gitignored - cleaning up so much in one pass! – Polacca

THIS IS IT. git config core.ignorecase false ended up duplicating the files on osx, but this is what reset the state & updated the names correctly. – Hannibal

Didn't work to me, git add --all . return everything back and git status says: "nothing to commit, working tree clean". What am I doing wrong? I was forced to git add all "ok-sensetive" files by hands, and the do commit with deleted "notok-sensetive" files. – Helmick

Doing this even made Sourctree recognize the changes. :-) Awesome! – Disappointed

This deserves to be accepted :( – Bair

Answer 4

Using SourceTree I was able to do this all from the UI

1. Rename FILE.ext to whatever.ext
2. Stage that file
3. Now rename whatever.ext to file.ext
4. Stage that file again

It's a bit tedious, but if you only need to do it to a few files it's pretty quick

Nyx

The same with git bash – Judaica

"Stage that file" is the important part - none of the other answers above worked for me. It actually worked with the plain old Windows command prompt. – Hills

I didn't realize this worked through the staging area. But in my case, I wanted to modify the folder names as well as some files within those folders. So I first renamed all folders to temporary names. Committed the new names (all files within) and the "deleted" files. Git flagged them all as "renamed". Then renamed all those folders back to their new case versions and committed again. Finally, merged those 2 commits. But based on what you wrote, I could have done the whole thing through the sating area directly, without creating 2 commits + merge. – Permanence

Works also with gitkraken on folder name. – Pinball

If your operating system is case insensitive changes to the filename will not appear in Sourcetree – Incised

Old I know, but this one liner should generate all the git commands you need to move the files. Pipe it into bash to actually run them, ie append '| bash', then do your git commit ``` find . -type f -name '[A-Z]' | while read a; do echo git mv $a $(dirname $a)/$(basename $a| tr 'A-Z' 'a-z'); done ``` this should do similar for dir names (more dangerous though) ``` find . -depth -type d -name '[A-Z]' | while read a; do echo git mv $a $(dirname $a)/$(basename $a| tr 'A-Z' 'a-z'); done ``` – Worried

This must be the simplest and easiest solution to understand suggested here. For git-noobs (like me) to "Stage" a file means to "add" a file without committing file. – Rockribbed

A mix of this and git mv worked for me. – Rhomboid

If you have a bunch of case changes, even simpler: drag all the icons out into a separate folder, stage the changes, drag them back, stage the changes, and that will pick up the case changes. – Gershwin

Answer 5

This is what I did on OS X:

git mv File file.tmp
git mv file.tmp file

Two steps because otherwise I got a “file exists” error. Perhaps it can be done in one step by adding --cached or such.

Jammie

as the top answer suggests, -f (force) is the flag you are looking for – Guadiana

@Guadiana - no, the -f flag doesn't help in case the underlying FS is case-insensitive. However, two-step solution worked for me – Asterism

Using a case-insensitive FS (on Mac) and -f worked! Thanks for the tip – Pious

This also worked with a folder on windows without the -f flag. – Urbani

git -c "core.ignorecase=false" add . will consider files whose case has been changed for commit. – Carpous

Answer 6

Sometimes it is useful to temporarily change Git's case sensitivity.

Method #1 - Change case sensitivity for a single command:

git -c core.ignorecase=true checkout mybranch to turn off case-sensitivity for a single checkout command. Or more generally: git -c core.ignorecase= <<true or false>> <<command>>. (Credit to VonC for suggesting this in the comments.)

Method #2 - Change case sensitivity for multiple commands:

To change the setting for longer (e.g. if multiple commands need to be run before changing it back):

1. git config core.ignorecase (this returns the current setting, e.g. false).
2. git config core.ignorecase <<true or false>> - set the desired new setting.
3. ...Run multiple other commands...
4. git config core.ignorecase <<false or true>> - set config value back to its previous setting.

Ecdysis

Why not directly git -c core.ignorecase=<true or false> checkout <<branch>>? Nothing to reset after. – Edholm

I had a weird experience of the proposed core.ignorecase working when changing from lowercase to uppercase, but not for uppercase to lowercase. seems the only reliable solution is to stop using an OS which fails to recognise filename case. – Fabian

Is there a reason why it should be a temporary change? Would that cause any problem if I just leave the settings changed to case sensitive? – Bil

This may depend on a few factors, in particular whether the target file system is case sensitive - see en.wikipedia.org/wiki/Case_sensitivity#In_filesystems. The temporary change may be needed if the deployment file system has different case sensitivity to the file system used for development. Also in my case I work in a team where everyone is expected to have the same Git settings (i.e. case sensitive) so if I turn it off it needs to be temporary. – Ecdysis

Answer 7

We can use git mv command. Example below , if we renamed file abcDEF.js to abcdef.js then we can run the following command from terminal

git mv -f .\abcDEF.js  .\abcdef.js

Nutter

Forcing is not needed anymore since git v2.0.1 (@see github.com/git/git/commit/… ) – Submersible

Answer 8

Under OSX, to avoid this issue and avoid other problems with developing on a case-insensitive filesystem, you can use Disk Utility to create a case sensitive virtual drive / disk image.

Run disk utility, create new disk image, and use the following settings (or change as you like, but keep it case sensitive):

Make sure to tell git it is now on a case sensitive FS:

git config core.ignorecase false

Lauder

Nah, nuclear is running a fully case-sensitive boot drive on OSX. You'll have to live without poorly written (ahem, Adobe) apps, or run those in their own case-stupid VM, but it's worth it if you code primarily for *nix systems. – Brinson

This is the only option that properly works. I've tried the rest and you end up in a pickle one way or another. Solve the problem properly by doing this. – El

Note that Disk Utility has a bug OS X 10.11 -- It won't create case sensitive images. You need to use the command line tool hdiutil. apple.stackexchange.com/questions/217915/… – Surplice

With APFS in High Sierra this is even easier. Click the icon of a drive with a plus and add a case-sensitive volume with no limits on size. It just shares space with the main volume and mounts at /Volumes/volume-name. – Modiolus

Answer 9

1. rename file Name.jpg to name1.jpg

2. commit removed file Name.jpg

3. rename file name1.jpg to name.jpg

4. amend added file name.jpg to previous commit

   git add name.jpg
   git commit --amend
   

Kcal

I am getting this fatal: bad source, source=name1.jpg, destination=name.jpg at step 3. Do you have suggestion? Thx – Homeopathic

You can not do a commit, just git add. – Judaica

Worked for me. Honestly, its actually correct from an audit point of view. – Kweiyang

As CBarr's answer notes, you don't need the intermediate commit here. You can just rename, stage, rename, stage, then commit, without the extra commit in the middle that this answer uses. – Devoir

Answer 10

Similar to @Sijmen's answer, this is what worked for me on OSX when renaming a directory (inspired by this answer from another post):

git mv CSS CSS2
git mv CSS2 css

Simply doing git mv CSS css gave the invalid argument error: fatal: renaming '/static/CSS' failed: Invalid argument perhaps because OSX's file system is case insensitive

p.s BTW if you are using Django, collectstatic also wouldn't recognize the case difference and you'd have to do the above, manually, in the static root directory as well

Addict

Answer 11

I tried the following solutions from the other answers and they didn't work:

• git mv filename
• git rm -f filename

If your repository is hosted remotely (GitHub, GitLab, BitBucket), you can rename the file on origin (GitHub.com) and force the file rename in a top-down manner.

The instructions below pertain to GitHub, however the general idea behind them should apply to any remote repository-hosting platform. Keep in mind the type of file you're attempting to rename matters, that is, whether it's a file type that GitHub deems as editable (code, text, etc) or uneditable (image, binary, etc) within the browser.

1. Visit GitHub.com
2. Navigate to your repository on GitHub.com and select the branch you're working in
3. Using the site's file navigation tool, navigate to the file you intend to rename
4. Does GitHub allow you to edit the file within the browser?
   • a.) Editable
     1. Click the "Edit this file" icon (it looks like a pencil)
     2. Change the filename in the filename text input
   • b.) Uneditable
     1. Open the "Download" button in a new tab and save the file to your computer
     2. Rename the downloaded file
     3. In the previous tab on GitHub.com, click the "Delete this file" icon (it looks like a trashcan)
     4. Ensure the "Commit directly to the branchname branch" radio button is selected and click the "Commit changes" button
     5. Within the same directory on GitHub.com, click the "Upload files" button
     6. Upload the renamed file from your computer
5. Ensure the "Commit directly to the branchname branch" radio button is selected and click the "Commit changes" button
6. Locally, checkout/fetch/pull the branch
7. Done

Cosec

I renamed directly on BitBucket and it worked. Thanks. – Prefrontal

Good to know. This technique should theoretically work on any repository hosting platform but I'd be interested to know if there are any that it would not work with. – Cosec

Doesn't work for files that can't be edited in the browser, like images or PDF; there is no edit option, obviously. – Nuri

@AbhijitSarkar Good point. I updated my answer for those cases. I tested and verified these instructions work. – Cosec

Answer 12

With the following command:

git config --global  core.ignorecase false

You can globally config your git system to be case sensitive for file and folder names.

Greenhouse

Answer 13

Years later I need to come back to this question and provide yet another possible solution! I ran into this issue on a project where only a single file needed to be renamed. This is what I did and it worked for me.

git mv -f src/MyFile.js src/myfile.js

Which I learned both from this thread and this answer

Nyx

Answer 14

Mac OSX High Sierra 10.13 fixes this somewhat. Just make a virtual APFS partition for your git projects, by default it has no size limit and takes no space.

1. In Disk Utility, click the + button while the Container disk is selected
2. Select APFS (Case-Sensitive) under format
3. Name it Sensitive
4. Profit
5. Optional: Make a folder in Sensitive called git and ln -s /Volumes/Sensitive/git /Users/johndoe/git

Your drive will be in /Volumes/Sensitive/

How do I commit case-sensitive only filename changes in Git?

Staffan

I love this suggestion, it elegantly and painlessly solves the problem without resort to ugly workarounds. Thanks! – Substrate

Just an advise, do not do that, Changing Hard format to APFS (Case-sensitive) makes your system very slow and you will face many weird issue, I faced ReactNative build issue, some addresses could not be found. so it's better to have APFS the default of the company. for git case it's better to use this solution. – Greenhouse

@Greenhouse This doesn't change your system hard drive, only a partition to Case Sensitive. Performance is actually slightly better with case-senstivity on. The solution you linked to does not work for everyone as code that assumes linux-like case senstivity may not run, such as when two files are the same name but different case. – Staffan

Answer 15

so there are many solutions to this case sensitivity deployment problem with how GitHub handles it.

In my case, I had changed the filename casing convention from uppercase to lowercase.

I do believe that git can track the change but this command git config core.ignorecase false dictates how git operates behind the scenes

In my case, I ran the command and git suddenly had lots of files to track labeled untracked.

I then hit git add. , then git committed and ran my build on netlify one more time.

Then all errors now displayed could be traced e.g Module not found: Can't resolve './Components/ProductRightSide' in '/opt/build/repo/components/products and fixed such that git was able to track and implement the changes successfully.

It's quite a workaround and a fingernail away from frustration but trust me this will surely work.

PS: after fixing your issue you may want to run the command git config core.ignorecase true to restore how git works with case sensitivity.

Also, note git config core.ignorecase false has issues with other filename extensions so you may want to watch out, do it if you know what you’re doing and are sure of it.

Here's a thread on netlify that can help out, possibly

Mariner

This is good but it seems to make the files as new, loosing all history rather than simply renaming the existing file with all of it's changes. – Widdershins

Answer 16

When you've done a lot of file renaming and some of it are just a change of casing, it's hard to remember which is which. manually "git moving" the file can be quite some work. So what I would do during my filename change tasks are:

1. remove all non-git files and folder to a different folder/repository.
2. commit current empty git folder (this will show as all files deleted.)
3. add all the files back into the original git folder/repository.
4. commit current non-empty git folder.

This will fix all the case issues without trying to figure out which files or folders you renamed.

Birdman

Why not git commmit --amend in In paragraph 4? Otherwise, there will be an extra commit with the removal of all files. Or you can use git rebase -i with squash. – Judaica

Answer 17

I've faced this issue several times on MacOS. Git is case sensitive but Mac is only case preserving.

Someone commit a file: Foobar.java and after a few days decides to rename it to FooBar.java. When you pull the latest code it fails with The following untracked working tree files would be overwritten by checkout...

The only reliable way that I've seen that fixes this is:

1. git rm Foobar.java
2. Commit it with a message that you cannot miss git commit -m 'TEMP COMMIT!!'
3. Pull
4. This will pop up a conflict forcing you to merge the conflict - because your change deleted it, but the other change renamed (hence the problem) it
   1. Accept your change which is the 'deletion'
   2. git rebase --continue
5. Now drop your workaround git rebase -i HEAD~2 and drop the TEMP COMMIT!!
6. Confirm that the file is now called FooBar.java

Jelena

-1. I can't repro the error you mention here, and without it the rest of the answer doesn't make sense. Also, doing git rebase --continue without a rebase in progress just yields a "No rebase in progress?" error, and there's no rebase in progress during step 4.2, so running that command there doesn't make sense either. – Devoir

Answer 18

I took @FiniteLooper answer and wrote a Python 3 Script to do it with a list of files:

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-

import os
import shlex
import subprocess

def run_command(absolute_path, command_name):
    print( "Running", command_name, absolute_path )

    command = shlex.split( command_name )
    command_line_interface = subprocess.Popen( 
          command, stdout=subprocess.PIPE, cwd=absolute_path )

    output = command_line_interface.communicate()[0]
    print( output )

    if command_line_interface.returncode != 0:
        raise RuntimeError( "A process exited with the error '%s'..." % ( 
              command_line_interface.returncode ) )

def main():
    FILENAMES_MAPPING = \
    [
        (r"F:\\SublimeText\\Data", r"README.MD", r"README.md"),
        (r"F:\\SublimeText\\Data\\Packages\\Alignment", r"readme.md", r"README.md"),
        (r"F:\\SublimeText\\Data\\Packages\\AmxxEditor", r"README.MD", r"README.md"),
    ]

    for absolute_path, oldname, newname in FILENAMES_MAPPING:
        run_command( absolute_path, "git mv '%s' '%s1'" % ( oldname, newname ) )
        run_command( absolute_path, "git add '%s1'" % ( newname ) )
        run_command( absolute_path, 
             "git commit -m 'Normalized the \'%s\' with case-sensitive name'" % (
              newname ) )

        run_command( absolute_path, "git mv '%s1' '%s'" % ( newname, newname ) )
        run_command( absolute_path, "git add '%s'" % ( newname ) )
        run_command( absolute_path, "git commit --amend --no-edit" )

if __name__ == "__main__":
    main()

Profile

Answer 19

Or simply rename the required file over git repository web UI interface and commit :)

Flare

Answer 20

If nothing worked use git rm filename to delete file from disk and add it back.

Microbalance

Try this answer if you ever come across this again https://mcmap.net/q/44965/-how-do-i-commit-case-sensitive-only-filename-changes-in-git – Diverticulosis

Answer 21

I made a bash script to lowercase repository file names for me:

function git-lowercase-file {
  tmp="tmp-$RANDOM-$1"
  git mv -f $1 $tmp
  git mv -f $tmp ${1,,}
}

then you can use it like this:

git-lowercase-file Name.jpg

Viafore

Answer 22

If you're doing more complex change, like directory name casing change, you can make that change from a Linux machine, because Linux itself (as well as git on Linux) treats files/directories with same names but different casing as completely different files/directories.

So if you're on Windows, you can install Ubuntu using WSL, clone your repo there, open the cloned repo directory using VSCode (use WSL remote extension to access WSL Ubuntu from Windows), then you will be able to make your renames through VSCode and commit/push them using VSCode git integration.

Hilaryhilbert