1# minimatch
2
3A minimal matching utility.
4
5[![Build Status](https://travis-ci.org/isaacs/minimatch.svg?branch=master)](http://travis-ci.org/isaacs/minimatch)
6
7
8This is the matching library used internally by npm.
9
10It works by converting glob expressions into JavaScript `RegExp`
11objects.
12
13## Usage
14
15```javascript
16var minimatch = require("minimatch")
17
18minimatch("bar.foo", "*.foo") // true!
19minimatch("bar.foo", "*.bar") // false!
20minimatch("bar.foo", "*.+(bar|foo)", { debug: true }) // true, and noisy!
21```
22
23## Features
24
25Supports these glob features:
26
27* Brace Expansion
28* Extended glob matching
29* "Globstar" `**` matching
30
31See:
32
33* `man sh`
34* `man bash`
35* `man 3 fnmatch`
36* `man 5 gitignore`
37
38## Minimatch Class
39
40Create a minimatch object by instantiating the `minimatch.Minimatch` class.
41
42```javascript
43var Minimatch = require("minimatch").Minimatch
44var mm = new Minimatch(pattern, options)
45```
46
47### Properties
48
49* `pattern` The original pattern the minimatch object represents.
50* `options` The options supplied to the constructor.
51* `set` A 2-dimensional array of regexp or string expressions.
52  Each row in the
53  array corresponds to a brace-expanded pattern.  Each item in the row
54  corresponds to a single path-part.  For example, the pattern
55  `{a,b/c}/d` would expand to a set of patterns like:
56
57        [ [ a, d ]
58        , [ b, c, d ] ]
59
60    If a portion of the pattern doesn't have any "magic" in it
61    (that is, it's something like `"foo"` rather than `fo*o?`), then it
62    will be left as a string rather than converted to a regular
63    expression.
64
65* `regexp` Created by the `makeRe` method.  A single regular expression
66  expressing the entire pattern.  This is useful in cases where you wish
67  to use the pattern somewhat like `fnmatch(3)` with `FNM_PATH` enabled.
68* `negate` True if the pattern is negated.
69* `comment` True if the pattern is a comment.
70* `empty` True if the pattern is `""`.
71
72### Methods
73
74* `makeRe` Generate the `regexp` member if necessary, and return it.
75  Will return `false` if the pattern is invalid.
76* `match(fname)` Return true if the filename matches the pattern, or
77  false otherwise.
78* `matchOne(fileArray, patternArray, partial)` Take a `/`-split
79  filename, and match it against a single row in the `regExpSet`.  This
80  method is mainly for internal use, but is exposed so that it can be
81  used by a glob-walker that needs to avoid excessive filesystem calls.
82
83All other methods are internal, and will be called as necessary.
84
85### minimatch(path, pattern, options)
86
87Main export.  Tests a path against the pattern using the options.
88
89```javascript
90var isJS = minimatch(file, "*.js", { matchBase: true })
91```
92
93### minimatch.filter(pattern, options)
94
95Returns a function that tests its
96supplied argument, suitable for use with `Array.filter`.  Example:
97
98```javascript
99var javascripts = fileList.filter(minimatch.filter("*.js", {matchBase: true}))
100```
101
102### minimatch.match(list, pattern, options)
103
104Match against the list of
105files, in the style of fnmatch or glob.  If nothing is matched, and
106options.nonull is set, then return a list containing the pattern itself.
107
108```javascript
109var javascripts = minimatch.match(fileList, "*.js", {matchBase: true}))
110```
111
112### minimatch.makeRe(pattern, options)
113
114Make a regular expression object from the pattern.
115
116## Options
117
118All options are `false` by default.
119
120### debug
121
122Dump a ton of stuff to stderr.
123
124### nobrace
125
126Do not expand `{a,b}` and `{1..3}` brace sets.
127
128### noglobstar
129
130Disable `**` matching against multiple folder names.
131
132### dot
133
134Allow patterns to match filenames starting with a period, even if
135the pattern does not explicitly have a period in that spot.
136
137Note that by default, `a/**/b` will **not** match `a/.d/b`, unless `dot`
138is set.
139
140### noext
141
142Disable "extglob" style patterns like `+(a|b)`.
143
144### nocase
145
146Perform a case-insensitive match.
147
148### nonull
149
150When a match is not found by `minimatch.match`, return a list containing
151the pattern itself if this option is set.  When not set, an empty list
152is returned if there are no matches.
153
154### matchBase
155
156If set, then patterns without slashes will be matched
157against the basename of the path if it contains slashes.  For example,
158`a?b` would match the path `/xyz/123/acb`, but not `/xyz/acb/123`.
159
160### nocomment
161
162Suppress the behavior of treating `#` at the start of a pattern as a
163comment.
164
165### nonegate
166
167Suppress the behavior of treating a leading `!` character as negation.
168
169### flipNegate
170
171Returns from negate expressions the same as if they were not negated.
172(Ie, true on a hit, false on a miss.)
173
174### partial
175
176Compare a partial path to a pattern.  As long as the parts of the path that
177are present are not contradicted by the pattern, it will be treated as a
178match.  This is useful in applications where you're walking through a
179folder structure, and don't yet have the full path, but want to ensure that
180you do not walk down paths that can never be a match.
181
182For example,
183
184```js
185minimatch('/a/b', '/a/*/c/d', { partial: true })  // true, might be /a/b/c/d
186minimatch('/a/b', '/**/d', { partial: true })     // true, might be /a/b/.../d
187minimatch('/x/y/z', '/a/**/z', { partial: true }) // false, because x !== a
188```
189
190### allowWindowsEscape
191
192Windows path separator `\` is by default converted to `/`, which
193prohibits the usage of `\` as a escape character. This flag skips that
194behavior and allows using the escape character.
195
196## Comparisons to other fnmatch/glob implementations
197
198While strict compliance with the existing standards is a worthwhile
199goal, some discrepancies exist between minimatch and other
200implementations, and are intentional.
201
202If the pattern starts with a `!` character, then it is negated.  Set the
203`nonegate` flag to suppress this behavior, and treat leading `!`
204characters normally.  This is perhaps relevant if you wish to start the
205pattern with a negative extglob pattern like `!(a|B)`.  Multiple `!`
206characters at the start of a pattern will negate the pattern multiple
207times.
208
209If a pattern starts with `#`, then it is treated as a comment, and
210will not match anything.  Use `\#` to match a literal `#` at the
211start of a line, or set the `nocomment` flag to suppress this behavior.
212
213The double-star character `**` is supported by default, unless the
214`noglobstar` flag is set.  This is supported in the manner of bsdglob
215and bash 4.1, where `**` only has special significance if it is the only
216thing in a path part.  That is, `a/**/b` will match `a/x/y/b`, but
217`a/**b` will not.
218
219If an escaped pattern has no matches, and the `nonull` flag is set,
220then minimatch.match returns the pattern as-provided, rather than
221interpreting the character escapes.  For example,
222`minimatch.match([], "\\*a\\?")` will return `"\\*a\\?"` rather than
223`"*a?"`.  This is akin to setting the `nullglob` option in bash, except
224that it does not resolve escaped pattern characters.
225
226If brace expansion is not disabled, then it is performed before any
227other interpretation of the glob pattern.  Thus, a pattern like
228`+(a|{b),c)}`, which would not be valid in bash or zsh, is expanded
229**first** into the set of `+(a|b)` and `+(a|c)`, and those patterns are
230checked for validity.  Since those two are valid, matching proceeds.
231