Re: How do I qualify paths in the .gitignore file w.r.t. the repo root directory?

[Junio C Hamano <gitster@pobox.com>]

Sitaram Chamarty <sitaramc@gmail.com> writes:

> On 2009-02-25, Junio C Hamano <gitster@pobox.com> wrote:
> ...
>> '!' is not part of _how_ the patterns match.  It is _what happens_ when a
>> pattern marked as such matches (meaning, the syntax for a line in
>> gitignore file is "an optional '!' followed by a pattern").
>>
>>     An optional prefix '!' is not a part of the pattern and it does not
>>     affect the match.  When a path matches such a pattern, instead of
>>     being ignored, it is unignored.
>
> I can use this.  Can we keep it in the same section, despite
> being technically not a '_how_'?  It fits the other sections
> even less, and the sectioning is the main thing in all this.

I thought making the text easier to follow was the main thing.

Sectioning could be part of the solution, but if we find that the boundary
between sections are blurry, or if there are too many sections compared to
the number of rules, perhaps dividing them into sections and giving each a
separate section header may make them even harder to follow.

I am actually very tempted to say that the correct description of the
gitignore language is:

    - an optional ! sign whose meaning is "unignore paths that matches
      this pattern, instead of ignoring them"; followed by

    - an optional / sign whose meaning is "a match with this pattern must
      be made at this directory and not in its subdirectories"; followed
      by

    - a pattern that never begins nor ends with a slash whose meaning is
      "this is a shell glob pattern to test paths against"; followed by

    - an optional / sign whose meaning is "this pattern matches only with
      a directory".

We'll need to tweak the language a bit in J6t's patch that talks about the
gitattributes pattern if we go this route, though.  The attribute system
uses the latter three that specify how a match is made, but does not use
the first one that specifies what happens once a match is found, because
the latter is done by the attributes part that follows the pattern in the
gitattributes file.

> Do we not want to specify that we don't descend?  The
> original text does say '...will match a directory foo and
> paths underneath it'.

Ok.  If we unignore a directory that does not mean all paths inside it are
now unignored --- they are still subject to .gitignore rules read from it
and its subdirectories.  So "will match it and paths inside it" is correct
but "will ignore it and paths inside it" is not.

>>> This is _where_ the patterns match (a trailing slash is
>>> ignored for these rules):
>>> ...
> And it'll _seem to_ contradict what we say, just above, that
> a trailing slash is ignored for these rules.

You are absolutely right.  Please scratch my comment on this item.