gitignore all files in folders but keep folder structure

user_2068362 0
Viewed 24387

I have the following folder structure:

/foo/
/foo/test.txt
/foo/.gitkeep
/foo/bar/test.txt
/foo/bar/.gitkeep
/foo/bar/baz/test.txt
/foo/bar/baz/.gitkeep

Now I want to exclude all files in the folder "foo" and all files in its subfolders (and subsubfolders), except all the .gitkeeps (so that the folder structure is kept). This should also work for more than 3 levels of subfolders.

The following gitignore-rules work:

/foo/**
!/foo/**/
!/foo/**/.gitkeep

Can somebody explain, why this works? Is there a cleaner way of doing this?

gitignore git
4 Answers

The rule is simple:

It is not possible to re-include a file if a parent directory of that file is excluded.

That is why you need to

  • ignore files and folders recursively:

    /foo/**

(if you only ignore /foo/, that is the folder, then no amount of '!' exclusion rule will work, since the foo/ folder itself is ignored: Git will stop there)

  • Then exclude folders from the ignore rules:

    !/foo/**/

  • Before whitelisting files like the .gitkeep

    !/foo/**/.gitkeep

That works because the .gitkeep parent folders are excluded from the ignore rules.

As opposed to Bernardo original proposal (before his edit):

/foo/** 
!**/.gitkeep

If does not exclude folders from the /** ignore rule, so the exclusion rule for files is inoperative.

You can check that with:

git check-ignore -v -- /path/to/.gitkeep

As mentioned in scm .gitignore:

  • using '*' is the same as '**'
  • using !.gitkeep (without any / anchor) would exclude that file recursively.

In both cases, 'recursively' is the key term which explains why exclusion rules can apply: if you ignore a folder (like . or /foo/), you won't be able to exclude anything inside that folder.
But if you ignore elements (files and folder) recursively (* or **), and exclude folders from gitignore rules (again through recursive rule !*), then you can exclude (white-list) files.

VonC_63090

I've done it. It seems that what is needed is a .gitignore file inside the desired folder.

Look at this repository, which does exactly what you want.

I've tried to add any filename inside foo/, foo/bar/ and foo/bar/baz/ but it only accepts .gitkeep.

The trick is to create a .gitignore with this content, inside the folder:

*
!*/
!.gitignore
!.gitkeep

[Edit: Added based on comments]

And you should be able to shorten this to:

*
!*/
!.git*

Though it may be less clear in the future what was intended.

While this solution doesn't shorten the number of lines required from your original .gitignore, this does have several other advantages - the main one being that this will be a .gitignore file inside the folder, which means it can be a clean file that has just these lines, and is specific to just this folder.

That means this .gitignore file can be easily moved into any specific folder that requires this filter. Also, the entire folder can be easily moved around within the repo, or even moved to a different repo, without needing to modify the .gitignore. It is much cleaner and more maintainable, and not buried in the typically large .gitignore file in the repo's root folder.

user_73959110

I don't have enough reputation to comment but I'd like to raise an important issue with this:

  • With mounted data folders, this causes git commands such as git status to run very slowly, because the commands still sweep through all the files (despite not committing them), which will run slowly through a network.

  • More unpredictably, this causes Oh My Zsh (if installed) to hang the shell for a while after each command, because it silently checks for the git branch (I raised this here).

One way to work around this is to do the following:

  1. Add this to your .gitignore:
data/**
!data/**/
!data/**/.gitkeep

  1. git add data

  2. Remove the second line from your .gitignore:

data/**
# !data/**/
!data/**/.gitkeep

  1. git add .gitignore

  2. git commit

This commits the data directory structure to git, and ensures that any future git calls will completely ignore the contents of your data subdirectories.

user_101436150

Empty directories cannot be committed to Git. So create a README.md file or any empty file and ignore all other files (using pattern match). This way directory will be committed with placeholder file.

user_32643440
Related