Reputation: 26576

Ignoring any 'bin' directory on a git project

I have a directory structure like this:

.git/
.gitignore
main/
  ...
tools/
  ...
...

Inside main and tools, and any other directory, at any level, there can be a 'bin' directory, which I want to ignore (and I want to ignore everything under it too). I've tried each of these patterns in .gitignore but none of them work:

/**/bin/**/*
/./**/bin/**/*
./**/bin/**/*
**/bin/**/*
*/bin/**/*
bin/**/*
/**/bin/* #and the others with just * at the end too

Can anyone help me out? The first pattern (the one I think should be working) works just fine if I do this:

/main/**/bin/**/*

But I don't want to have an entry for every top-level directory and I don't want to have to modify .gitignore every time I add a new one. There are also files and directories that have the substring 'bin' in their names, which I want to keep.

This is on Windows using the latest msysgit.

Upvotes: 1487

Answers (17)

w. Patrick Gale

Reputation: 2347

I had the same problem with __pycache__ files that snuck into my repository without me noticing. When I added **/__pycache__ to my .gitignore I was still seeing some pycache files showing in my Git change list. Running local git cache clearing commands did not help.

I had to insure the files, that do not seem to be ignored by .gitignore, were not currently in my repository. The files did exist in my repository which meant .gitignore patterns would not work on those files. I deleted the files from my repository that I wanted ignored. I then discarded changes on those files in my local code since they were still showing in my 'Change' list. I then synced my local code to the repository, and after that .gitignore patterns began working to ignore those files.

Upvotes: 0

CB Bailey

Reputation: 793249

Before version 1.8.2, ** didn't have any special meaning in the .gitignore. As of 1.8.2 git supports ** to mean zero or more sub-directories (see release notes).

The way to ignore all directories called bin anywhere below the current level in a directory tree is with a .gitignore file with the pattern:

bin/

In the man page, there an example of ignoring a directory called foo using an analogous pattern.

If you already have any bin folders in your git index which you no longer wish to track then you need to remove them explicitly. Git won't stop tracking paths that are already being tracked just because they now match a new .gitignore pattern. Execute a folder remove (rm) from index only (--cached) recursivelly (-r). Command line example for root bin folder:

git rm -r --cached bin

Upvotes: 2167

Norman

Reputation: 3479

In addition to @CB Bailey's answer:

I tried to remove multiple folders (in subfolders) named et-cache (caching folder from Wordpress divi theme) from the index and from being tracked.

I added

et-cache/

to the .gitignore file. But

git rm -r --cached et-cache

resulted in an error:

fatal: pathspec 'et-cache' did not match any files

So the solution was to use powershell:

Get-ChildItem et-cache -Recurse |% {git rm -r --cached $_.FullName}

This searches for all subfolders named et-cache. Each of the folders path (fullname) is then used to remove it from tracking in git.

Upvotes: 2

Bravo Yeung

Reputation: 9888

Step 1: Add following content to the file .gitignore.

# User-specific files
*.suo
*.user
*.userosscache
*.sln.docstates

# Build results
[Dd]ebug/
[Dd]ebugPublic/
[Rr]elease/
[Rr]eleases/
x64/
x86/
bld/
[Bb]in/
[Oo]bj/

# Visual Studio 2015 cache/options directory
.vs/

Step 2: Make sure take effect

If the issue still exists, that's because settings in .gitignore can only ignore files that were originally not tracked. If some files have already been included in the version control system, then modifying .gitignore is invalid. To solve this issue completely, you need to open Git Bash or Package Manager Console (see screenshot below) to run following commands in the repository root folder.

git rm -r --cached .
git add .
git commit -m "Update .gitignore"

Then the issue will be completely solved.

Upvotes: 46

Jacek Plesnar

Reputation: 505

In my case encoding of gitignore file was problematic, check if it is UTF-8

Upvotes: 1

prosti

Reputation: 46479

If the pattern inside .gitignore ends with a slash /, it will only find a match with a directory.

In other words, bin/ will match a directory bin and paths underneath it, but will not match a regular file or a symbolic link bin.

If the pattern does not contain a slash, like in bin Git treats it as a shell glob pattern (greedy). So best would be to use simple /bin.

bin would not be the best solution for this particular problem.

Upvotes: 2

AnthonyWC

Reputation: 1960

Literally none of the answers actually worked for me; the only one that worked for me was (on Linux):

**/bin
(yes without the / in the end)

git version 2.18.0

Upvotes: 18

Nikhil Karanjkar

Reputation: 105

for 2.13.3 and onwards,writing just bin in your .gitignore file should ignore the bin and all its subdirectories and files

bin

Upvotes: 7

Dhwaneel

Reputation: 551

Adding **/bin/ to the .gitignore file did the trick for me (Note: bin folder wasn't added to index).

Upvotes: 4

Jochen van Wylick

Reputation: 5401

If you're looking for a great global .gitignore file for any Visual Studio ( .NET ) solution - I recommend you to use this one: https://github.com/github/gitignore/blob/master/VisualStudio.gitignore

AFAIK it has the most comprehensive .gitignore for .NET projects.

Upvotes: 20

plancys

Reputation: 3923

I think it is worth to mention for git beginners:

If you already have a file checked in, and you want to ignore it, Git will not ignore the file if you add a rule later. In those cases, you must untrack the file first, by running the following command in your terminal:

git rm --cached

So if you want add to ignore some directories in your local repository (which already exist) after editing .gitignore you want to run this on your root dir

git rm --cached -r .
git add .

It will basically 'refresh' your local repo and unstage ignored files.

See:

http://git-scm.com/docs/git-rm,

https://help.github.com/articles/ignoring-files/

Upvotes: 301

Kerem

Reputation: 11586

As a notice;

If you think about .gitignore does not work in a way (so added foo/* folder in it but git status still showing that folder content(s) as modified or something like this), then you can use this command;

git checkout -- foo/*

Upvotes: 5

Jaider

Reputation: 14974

[Bb]in will solve the problem, but... Here a more extensive list of things you should ignore (sample list by GitExtension):

#ignore thumbnails created by windows
Thumbs.db
#Ignore files build by Visual Studio
*.user
*.aps
*.pch
*.vspscc
*_i.c
*_p.c
*.ncb
*.suo
*.bak
*.cache
*.ilk
*.log
[Bb]in
[Dd]ebug*/
*.sbr
obj/
[Rr]elease*/
_ReSharper*/

Upvotes: 27

wisbucky

Reputation: 38033

[Bb]in/

matches both upper and lower case

Upvotes: 52

VonC

Reputation: 1329672

The ** never properly worked before, but since git 1.8.2 (March, 8th 2013), it seems to be explicitly mentioned and supported:

The patterns in .gitignore and .gitattributes files can have **/, as a pattern that matches 0 or more levels of subdirectory.

E.g. "foo/**/bar" matches "bar" in "foo" itself or in a subdirectory of "foo".

In your case, that means this line might now be supported: