Telling git to ignore symlinks

This question has appeared in similar forms here and here, but they don't seem to match up with what I'm looking for.

I'm making a project in StaticMatic, a Ruby static site generator. Basically, it's just a src/ directory with Haml templates, Sass, and CoffeeScript. StaticMatic provides a development server to keep compiling these into a static site, as well as a build command that generates the static site in build/.

My modification to StaticMatic is to allow the addition of src/_modules/foo/, which might contain src/_modules/foo/bar.haml. When running the server or building the site, a symlink would be created at src/bar.haml which points to the file in foo/.

So far so good. (Conflicts are handled, etc.)

The reasoning behind separate directories in _modules/ is that they could be tracked as git submodules and checked out independently by other teams. Essentially, this allows multiple teams to work on different pages (actually JS apps) in one static site without duplicating the main layout and such.

The hitch is that git wants to think of these symlinks as files. For instance, git status shows:

# On branch master
# Untracked files:
#   (use "git add <file>..." to include in what will be commited)
#
#       src/_modules/bar/foo.haml
#       src/foo.haml

...when I really just want it to show src/_modules/bar/foo.haml and to ignore src/foo.haml

One approach would be to have my link-generating code append the links to .gitignore, but messing with .gitignore programmatically strikes me as prone to error. (Perhaps this concern isn't reasonable?)

My ideal fix would be something like:

[filetype = link]

...in .gitignore. As far as I know nothing like this is possible, or is it?

This seems to be a better idea

find . -type l | sed -e s'/^\.\///g' >> .gitignore

Find outputs a "./" prefix for all files. Unless you trim it off, gitignore is unable to act on them . Once you trim the "." at the beginning , it works like a charm

Depending on what version of git you are using it should follow symlinks. There's a config setting core.symlinks, that may be set to false and thus not letting git follow them as directories (assuming git >= 1.6). It seems completely reasonable to have your symlinking script also append those links to the .gitignore file or just add them yourself. You could also do something like find . -type l >> .gitignore

We had a similar issue where we needed to ignore a symlinked directory or a real directory, but not a subdirectory of the same name or a file starting with the same letters. For example:

• Ignore - (symlink) ./media
• Ignore - (directory) ./media
• Do not ignore - ./something/media
• Do not ignore - ./media.bak
• Do not ignore - ./media-somethingelse

I ended up using this in the .gitignore:

media
!*/media

Which looks a little strange but is basically saying (line 1) ignore everything "media" but (line 2) do not ignore anything "media" that isn't in the root directory. This method does require a little specificity (in regards to not ignoring things in subdirectories) but should be pretty easy to adapt/extend.

My answer from another question is relevant.

This method only adds untracked symlinks so can be repeated without adding duplicate entries, symlinks that are in submodules or are otherwise already ignored, or intentionally tracked symlinks.

for f in $(git status --porcelain | grep '^??' | sed 's/^?? //'); do
    test -L "$f" && echo $f >> .gitignore;
    test -d "$f" && echo $f\* >> .gitignore;
done

I used the most suitable solution to me - naming agreement.

With files Each symlink to file in my solution had a prefix in a name like "bla.outsidemodule.ts". In .gitignore file, I had just:

**/*.outsidemodule.*

With folders Also on the root of the solution, I had folder "platform", which had common libs/modules for other parts of the solution. The structure was like it:

 - ./platform              <- sources
 - ./client/src/platform   <- symlink to ./platform
 - ./server/src/platform   <- symlink to ./platform
 - ./exchange/src/platform <- symlink to ./platform
 - ./service/src/platform  <- symlink to ./platform

And in .gitignore just:

**/platform <- exclude all "platform" folders
!./platform <- do not exclude folder "platform" if it's on a root 

My solution might seem silly, but I'd rather do this than update the .gitignore file every time a new file is added.

I merely leave the links with a default name like "link to xxx" and then add the following line to my .gitignore file:

link to *

Then you just ensure you do not name any other files/folders with a name starting with "link to " and you're sorted.

If you really want to ignore a filename if it's a symlink or file but not if it is a directory, you can add to .gitignore :

/media
!/media/

To formulate it like @Chris_Rasys, this will :

• Ignore - (symlink) ./media
• Ignore - (file) ./media
• Do not ignore - (directory) ./media
• Do not ignore - ./something/media
• Do not ignore - ./media.bak
• Do not ignore - ./media-somethingelse

I don't keep the executables, and symlinks in my repository... so I want to omit them as well when I do a "git status".

If, like me, you want to ignore symlinks, directories and executables (ala some of the files in $NAG_HOME/libexec you can add those files into .gitignore as follows:

   file * | egrep 'ELF|symbolic|directory' | awk -F\: '{ print $1 }' >> .gitignore

   echo ".gitignore" >> .gitignore

Then, when you do a git status, it won't spit back the list of those files if you have not added them to your repository.