I have an existing Visual Studio project in my repository. I recently added a .gitignore file under my project and I assume that tells Git to ignore the files listed in the file.
My problem is that all those files are already being tracked and as far as I know Git will not ignore a file that was already tracked before a rule was added to this file to ignore it.
It was suggested to use: git rm --cached and manually un-track them but that's going to take me forever to go through them one by one.
I thought about deleting the repository and recreating it again but this time with .gitignore file present, but there must be a better way to do this.
If you added your .gitignore too late, git will continue to track already commited files regardless. To fix this, you can always remove all cached instances of the unwanted files.
First, to check what files are you actually tracking, you can run:
git ls-tree --name-only --full-tree -r HEAD
Let say that you found unwanted files in a directory like cache/ so, it's safer to target that directory instead of all of your files.
So instead of:
git rm -r --cached .
It's safer to target the unwanted file or directory:
git rm -r --cached cache/
Then proceed to add all changes,
git add .
and commit...
git commit -m ".gitignore is now working"
Reference: https://amyetheredge.com/code/13.html
As specified here You can update the index:
git update-index --assume-unchanged /path/to/file
By doing this, the files will not show up in git status or git diff.
To begin tracking the files again you can run:
git update-index --no-assume-unchanged /path/to/file
Create a .gitignore file, so to do that, you just create any blank .txt file.
Then you have to change its name writing the following line on the cmd (where git.txt is the name of the file you've just created):
rename git.txt .gitignore
Then you can open the file and write all the untracked files you want to ignore for good. For example, mine looks like this:
```
OS junk files
[Tt]humbs.db
*.DS_Store
#Visual Studio files
*.[Oo]bj
*.user
*.aps
*.pch
*.vspscc
*.vssscc
*_i.c
*_p.c
*.ncb
*.suo
*.tlb
*.tlh
*.bak
*.[Cc]ache
*.ilk
*.log
*.lib
*.sbr
*.sdf
*.pyc
*.xml
ipch/
obj/
[Bb]in
[Dd]ebug*/
[Rr]elease*/
Ankh.NoLoad
#Tooling
_ReSharper*/
*.resharper
[Tt]est[Rr]esult*
#Project files
[Bb]uild/
#Subversion files
.svn
# Office Temp Files
~$*
There's a whole collection of useful .gitignore files by GitHub
Once you have this, you need to add it to your git repository just like any other file, only it has to be in the root of the repository.
Then in your terminal you have to write the following line:
git config --global core.excludesfile ~/.gitignore_global
From oficial doc:
You can also create a global .gitignore file, which is a list of rules for ignoring files in every Git repository on your computer. For example, you might create the file at ~/.gitignore_global and add some rules to it.
Open Terminal. Run the following command in your terminal: git config --global core.excludesfile ~/.gitignore_global
If the respository already exists then you have to run these commands:
git rm -r --cached .
git add .
git commit -m ".gitignore is now working"
If the step 2 doesn´t work then you should write the hole route of the files that you would like to add.
Use git clean
Get help on this running
git clean -h
If you want to see what would happen first, make sure to pass the -n switch for a dry run:
git clean -xn
To remove gitingnored garbage
git clean -xdf
Careful: You may be ignoring local config files like database.yml which would also be removed. Use at your own risk.
Then
git add .
git commit -m ".gitignore is now working"
git push
I think this is an easy way for adding a .gitignore file to an existing repository.
Prerequisite:
You need a browser to access your github account.
Steps
Have fun!
Here is one way to “untrack” any files that are would otherwise be ignored under the current set of exclude patterns:
(GIT_INDEX_FILE=some-non-existent-file \
git ls-files --exclude-standard --others --directory --ignored -z) |
xargs -0 git rm --cached -r --ignore-unmatch --
This leaves the files in your working directory but removes them from the index.
The trick used here is to provide a non-existent index file to git ls-files so that it thinks there are no tracked files. The shell code above asks for all the files that would be ignored if the index were empty and then removes them from the actual index with git rm.
After the files have been “untracked”, use git status to verify that nothing important was removed (if so adjust your exclude patterns and use git reset -- path to restore the removed index entry). Then make a new commit that leaves out the “crud”.
The “crud” will still be in any old commits. You can use git filter-branch to produce clean versions of the old commits if you really need a clean history (n.b. using git filter-branch will “rewrite history”, so it should not be undertaken lightly if you have any collaborators that have pulled any of your historical commits after the “crud” was first introduced).
Source: Stackoverflow.com