.hgignore regex syntax to ignore a specific file (e.g. "core") anywhere

Question

Suppose I have a working directory like this:

1. t.c
2. core
3. multicore
4. test1/core

I want to ignore all "core" files.

• If I use "/core$" (4) will get ignored but not (2).
• If I use "^core$" (2) will get ignored but not (4)
• If I use "core$" (2) and (4) will get ignored but so will (3) which is not what I want.

How do you do this?

Answer 1

Try to give the filename using glob syntax:

syntax: glob
core

It gives:

~/hg-test$ hg st -A
M .hgignore
? multicore
I core
I dir1/core

Answer 2

planetmaker's answer, "use glob syntax", is simpler and is what I would usually recommend. There is, however, a regexp answer, and a minor flaw in the glob syntax version.

Mercurial uses Python regular expressions, so we have the (alt1|alt2|...) syntax available. Note that these are grouped.¹ We can and should use (?:...) to avoid grouping when required, but for .hgignore, the grouping is irrelevant, so it is simpler (and much more readable) to just use the parentheses, and I do so where possible below.

We could just write:

^core$
/core$

to ignore the file core with nothing coming before it (first pattern) and to ignore a file with a name like test1/core (second pattern). This is a fine, but we can compress it a bit more using the alternation syntax. The leading ^ works even in an alternate within a group, as long as it is still, in effect, leading, so:

(^|/)core$

means the same thing and accomplish the job using regexp syntax.

Annoyingly, all of these patterns ignore all files in any directory named core (whether or not we use regexp vs glob syntax):

$ rm core
$ mkdir core
$ touch core/keepme
$ cat .hgignore
syntax: glob
core
$ hg status -A
? .hgignore
? multicore
? t.c
I core/keepme
I test1/core

The problem is that as soon as we say ignore (some pattern that matches a directory named core), if there are files in that directory that are currently untracked, Mercurial ignores them too. You can forcibly add the file—as with Git, once a file is tracked, any ignore-file pattern that matches it becomes irrelevant—but this does not help with additional files we stick into the directory:

$ hg add core/keepme
$ touch core/keep-me-too
$ hg status -A
A core/keepme
? .hgignore
? multicore
? t.c
I core/keep-me-too
I test1/core

Here, regular expressions can prove to be the answer. Python (and Perl) regexps allow "negative lookbehind", i.e., you can say "as long as some pattern does not appear". Hence we can replace the existing .hgignore contents with:

$ cat .hgignore
(?<!^core/).*/core$

and now we have this status:

$ hg status -A
A core/keepme
? .hgignore
? core/keep-me-too
? multicore
? t.c
I test1/core

This particular regular expression depends on the wanted core directory being named core at the top level (^core). If we wanted to keep core directories named core (top level) and a/subsys/core, we would write:

(?<!(^core|^a/subsys/core)/).*/core$

as our regular expression.

Constructing these regexps is something of an art form, and rarely worth a lot of effort. Glob syntax is almost always simpler, and as long as it suffices, I prefer it. It was once significantly slower than regexp syntax but this was fixed back around Mercurial 3.1.

---

¹Grouped, here, means that in Python code, we may use the .groups() method to obtain the parts of the string matched by these parts of the regular expressions. Non-grouped (?:...) expressions do not affect the way .groups() gathers the parts of the strings. As in the paragraph to which this is a footnote, this is more a concern when writing Python (or Perl, or whatever) code, not when using these patterns in .hgignore or other parts of Mercurial.