无法将丢失的文件添加到 VS2015 VSO Git

Question

I have added some public lib files manually (ie not via Bower) to a MEAN project. My local Git repo is happy that they are new (see attached image). However, when I try to either 'Commit' or 'Commit and Push' I get the error message 'No changes; nothing to commit':

What's going on? How can I force these new files into the shared repo so that other devs can pull them?

Answer 1

Check your .gitignore file.

Visual Studio sometimes gets confused about what to show in the Included Changes section, because it's not just relying on what git tells it. I believe it monitors the filesystem for changes (but see note below)), and I think it also may hook into the events Visual Studio raises to tell source control providers about changes (which, way back, used to be the only kind of change source control providers would ever notice).

This can cause various problems. One is that VS may fail to realised that git is going to decide that a file doesn't really need to be handled - eg, either because it doesn't look to git like it's different from the previous version (and line endings can complicate matters here), or apparently, as in this case, because it's in the .gitignore . Normally VS does honour the .gitignore , but there are scenarios in which it doesn't. Eg, I think if VS saw the file being added at a time when it wasn't listed in .gitignore , it can then stay in the list after you've told git to ignore it.

There are more subtle problems that can arise too - when you move or rename files, Visual Studio can form a different opinion from git on what really happened. (Eg, the VS git provider might have been notified by VS that a particular file was renamed, but git doesn't have that history, and if the file has changed enough it might decide that it's actually a new file.)

As a general rule, run git status at the command line to see what git really thinks. That will report the definitive truth - if git doesn't list something here as having changed, then it doesn't matter what VS reports.

NOTE: (added in edit 2015/11/30). In the comments, Edward Thomson says that "VS doesn't simply throw paths into a list based on filesystem activity, it recomputes the git status." So perhaps my explanation for why VS sometimes shows confusing things is wrong. Then again, it can't just be (as Edward put it) "recomput[ing] the git status" because VS very often comes up with a different answer from git. (That, after all, is why Chris posted his question in the first place.)

Also, Edward Thomson says, "You must have a .gitignore in place before creating the file (like with git add.)" But for at least one reasonable definition of "creating the file", this is not so. Eg:

PS C:\temp\gittest> git init
Initialized empty Git repository in C:/temp/gittest/.git/
PS C:\temp\gittest> notepad Test.foo

If type in some text and save the file in notepad, then I have "created the file" at this point. Here's how git sees it:

PS C:\temp\gittest> git status
On branch master

Initial commit

Untracked files:
  (use "git add <file>..." to include in what will be committed)

        Test.foo

nothing added to commit but untracked files present (use "git add" to track)

Created, but not added. (Two different things, as far as git is concerned.) Now I'm going to go on and create a .gitignore:

PS C:\temp\gittest> notepad .gitignore

I type in *.foo and save the file, and then continue at the command line, starting by verifying that my .gitignore contains what I think it does:

PS C:\temp\gittest> type .\.gitignore
*.foo
PS C:\temp\gittest> git status
On branch master

Initial commit

Untracked files:
  (use "git add <file>..." to include in what will be committed)

        .gitignore

nothing added to commit but untracked files present (use "git add" to track)
PS C:\temp\gittest>

As you can see I did not initially have a .gitignore in place, so the first time I ran git status it reported my Test.foo file as being Untracked (so it would get added if I did a git add . ) but then I added a .gitignore later and when I ran git status again it had stopped showing my Test.foo because my newly added .gitignore told it to. Thus we see that contrary to Edward's statement, it was absolutely fine to create the .gitignore after creating the file.

I think the heart of this is that Edward conflates creating the file with adding it to git's index. He wrote the phrase "creating the file (like with git add.)" but those aren't the same - creating the file is a distinct step from using git add . And for me (and for a lot of the people I know who learned who learned git on the command line, and have subsequently struggled slightly with VS) this is exactly why VS's git integration can sometimes be so surprising. Using git directly, creating a file is a very different, separate step from telling git to do something with that file. Git shows newly created files as 'Untracked', and only starts paying proper attention to them if you git add them. (And actually committing the file is yet another separate step again of course.)

What I found very confusing at first is that VS's git support looks like it's making the same distinction: you have "Untracked Files", "Included Changes" and actual commits. It's not immediately obvious that VS's notion of an "Untracked File" is not at all the same as git's - everything VS shows in "Included Changes" still shows up as "Untracked files" in git (or, in Chris's case, doesn't show up at all because of the .gitignore .) In git, you move files from the "Untracked" to the "In git's purview but not yet committed" state with git add . Conversely, the mechanism by which VS decides whether files should be in "Included Changes" vs "Untracked Files" is a complete mystery to me. If you add new files to a project, they mostly end up in "Included Changes" but occasionally end up in "Untracked Files" for no obvious reason.

The thing that makes "Included Changes" particularly baffling for git command line users is that VS appears to apply rules for .gitignore to those files in the same way as git would if you had already added the files, but the files have not in fact been added. And this is exactly what leads to the situation Chris encountered in his question: VS thinks there are changes to commit (because it's processing the Included Changes as though git add had already been done for those) but there aren't (because as far as git is concerned, these are all Untracked files, and so they are all subject to .gitignore ).

This is what lead me to think tha VS must be monitoring the filesystem for changes - in the absence of a direct equivalent to the explicit git add operations we perform at the command line, I don't know how it could even know whether a particular file was created before or after .gitignore if it wasn't watching the filesystem.