Git revert/checkout for specific files touches them, but leaves contents unchanged

Question

My co-worker added some .ps1 files some time ago (several commits since, he might have modified only one of them again later etc. - so we can't assume it was all done in one commit). Let's say they were added in commit1 and later one of the files was modified in commit5.

I then accidentally committed some local changes (specific to my environment) to those .ps1 files, in addition to other changes I really wanted to commit. I had simply staged all changes and forgot to exclude my changes to the .ps1 files (which I want to keep locally, but not commit). We can call this commit14.

I then made another commit (to other files, commit15) and pushed my changes.

Basically it looks like this:

commit15   me         Foo.cs, Bar.cs
commit14   me         Foo.cs, Bazz.cs, [File1.ps1, File2.ps1, File3.ps1]
commit13   co-worker  SomeCode.cs
...
commit5    co-worker  File2.ps1
...
commit1    co-worker  File1.ps1, File2.ps1, File3.ps1 (added)

I have since tried to revert these three .ps1 files (marked in square brackets above) by discarding any local changes in Bitkraken and then cd'ing into the directory containing the files and running:

$ git checkout commit14~1 -f -- File1.ps1 File2.ps1 File3.ps1

There was no output, but the files were then automatically listed as staged in Bitkraken. That got my hopes up - but then I realized the file contents were identical (including the changes I wanted to revert).

I have also tried like this:

$ git reset commit14~1 -- File1.ps1 File2.ps1 File3.ps1

The output was as follow:

Unstaged changes after reset:
M       My/Path/File1.ps1
M       My/path/File2.ps1
M       My/Path/File3.ps1

Again the result was the same, the file contents were not changed. I have even tried specifying "commit13" explicitly instead of "commit14~1", but that didn't work either.

What am I doing wrong?

All of this happened on a branch called "dev", in case that matters.

And I'm not sure about the actual history of the .ps1 files, but I would strongly prefer if I didn't have to find out the last commit for each of them. This could easily have been more than 3 files. Surely there must be a way to say "Change these files back to the way they were before I accidentally committed them, no matter when they were last updated".

Thanks.

Answer 1

The easiest way to remove files from version control is

git rm <file name>
git commit

If you still need these files as part of your local configuration, just back them up to another folder and copy them back to your project's folder after you run these commands.

You should also add configuration files to .gitignore so that you avoid this mistake in the future.

Answer 2

I took at look the git rebase -i HEAD~2 command option for you, but it looks like that will only let you edit commit messages and does not let you remove files added during that commit. Give that to be the case you will need to roll-back the commits and re-apply them one at time. That would be done by performing the following:

Reset your previous commit and stash it:

git reset --soft HEAD~1
git stash

Then reset the commit previous to that (the one with the extra files):

git reset --soft HEAD~1

After resetting that commit, those mal-commited files will still be staged for commit. Remove them from the upcoming staged commit using:

git reset My/Path/File1.ps1
git reset My/Path/File2.ps1
git reset My/Path/File3.ps1

Now that the files are removed from the staged commit, updated (or create) a .gitignore file in the root of your repo. In the .gitignore file add the following line to ignore all .ps1 files:

*.ps1

Alternatively, if you don't want to ignore all .ps1 files you can explicitly path out the files you want ignored by adding these three lines:

My/Path/File1.ps1
My/Path/File2.ps1
My/Path/File3.ps1

Once your .gitignore file is updated, make sure to add it to your upcoming commit:

git add .gitignore

You can then complete you commit, this time without the concern of the .ps1 files ever being accidentally committed again.

To reapply the other commit you stashed, pop your stash and complete that commit also, using these commands:

git stash pop
git commit -m "relevant commit message"

The steps above should have undone, corrected, and reapplied those commits using the git commands: git reset, git stash, and git commit

If you are afraid of messing something up, create a branch first to save your previous work by executing these commands before starting the steps above:

git checkout -b [new branch name]
git checkout [previous branch name]

This should store all your messed up commits away in an old branch in case you want to come back to them.