vnfmarket/src/main/webapp/vnfmarket/node_modules/minimatch/README.md

   1 # minimatch
   2
   3 A minimal matching utility.
   4
   5 [![Build Status](https://secure.travis-ci.org/isaacs/minimatch.png)](http://travis-ci.org/isaacs/minimatch)
   6
   7
   8 This is the matching library used internally by npm.
   9
  10 It works by converting glob expressions into JavaScript `RegExp`
  11 objects.
  12
  13 ## Usage
  14
  15 ```javascript
  16 var minimatch = require("minimatch")
  17
  18 minimatch("bar.foo", "*.foo") // true!
  19 minimatch("bar.foo", "*.bar") // false!
  20 minimatch("bar.foo", "*.+(bar|foo)", { debug: true }) // true, and noisy!
  21 ```
  22
  23 ## Features
  24
  25 Supports these glob features:
  26
  27 * Brace Expansion
  28 * Extended glob matching
  29 * "Globstar" `**` matching
  30
  31 See:
  32
  33 * `man sh`
  34 * `man bash`
  35 * `man 3 fnmatch`
  36 * `man 5 gitignore`
  37
  38 ## Minimatch Class
  39
  40 Create a minimatch object by instanting the `minimatch.Minimatch` class.
  41
  42 ```javascript
  43 var Minimatch = require("minimatch").Minimatch
  44 var 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
  83 All other methods are internal, and will be called as necessary.
  84
  85 ## Functions
  86
  87 The top-level exported function has a `cache` property, which is an LRU
  88 cache set to store 100 items.  So, calling these methods repeatedly
  89 with the same pattern and options will use the same Minimatch object,
  90 saving the cost of parsing it multiple times.
  91
  92 ### minimatch(path, pattern, options)
  93
  94 Main export.  Tests a path against the pattern using the options.
  95
  96 ```javascript
  97 var isJS = minimatch(file, "*.js", { matchBase: true })
  98 ```
  99
 100 ### minimatch.filter(pattern, options)
 101
 102 Returns a function that tests its
 103 supplied argument, suitable for use with `Array.filter`.  Example:
 104
 105 ```javascript
 106 var javascripts = fileList.filter(minimatch.filter("*.js", {matchBase: true}))
 107 ```
 108
 109 ### minimatch.match(list, pattern, options)
 110
 111 Match against the list of
 112 files, in the style of fnmatch or glob.  If nothing is matched, and
 113 options.nonull is set, then return a list containing the pattern itself.
 114
 115 ```javascript
 116 var javascripts = minimatch.match(fileList, "*.js", {matchBase: true}))
 117 ```
 118
 119 ### minimatch.makeRe(pattern, options)
 120
 121 Make a regular expression object from the pattern.
 122
 123 ## Options
 124
 125 All options are `false` by default.
 126
 127 ### debug
 128
 129 Dump a ton of stuff to stderr.
 130
 131 ### nobrace
 132
 133 Do not expand `{a,b}` and `{1..3}` brace sets.
 134
 135 ### noglobstar
 136
 137 Disable `**` matching against multiple folder names.
 138
 139 ### dot
 140
 141 Allow patterns to match filenames starting with a period, even if
 142 the pattern does not explicitly have a period in that spot.
 143
 144 Note that by default, `a/**/b` will **not** match `a/.d/b`, unless `dot`
 145 is set.
 146
 147 ### noext
 148
 149 Disable "extglob" style patterns like `+(a|b)`.
 150
 151 ### nocase
 152
 153 Perform a case-insensitive match.
 154
 155 ### nonull
 156
 157 When a match is not found by `minimatch.match`, return a list containing
 158 the pattern itself if this option is set.  When not set, an empty list
 159 is returned if there are no matches.
 160
 161 ### matchBase
 162
 163 If set, then patterns without slashes will be matched
 164 against the basename of the path if it contains slashes.  For example,
 165 `a?b` would match the path `/xyz/123/acb`, but not `/xyz/acb/123`.
 166
 167 ### nocomment
 168
 169 Suppress the behavior of treating `#` at the start of a pattern as a
 170 comment.
 171
 172 ### nonegate
 173
 174 Suppress the behavior of treating a leading `!` character as negation.
 175
 176 ### flipNegate
 177
 178 Returns from negate expressions the same as if they were not negated.
 179 (Ie, true on a hit, false on a miss.)
 180
 181
 182 ## Comparisons to other fnmatch/glob implementations
 183
 184 While strict compliance with the existing standards is a worthwhile
 185 goal, some discrepancies exist between minimatch and other
 186 implementations, and are intentional.
 187
 188 If the pattern starts with a `!` character, then it is negated.  Set the
 189 `nonegate` flag to suppress this behavior, and treat leading `!`
 190 characters normally.  This is perhaps relevant if you wish to start the
 191 pattern with a negative extglob pattern like `!(a|B)`.  Multiple `!`
 192 characters at the start of a pattern will negate the pattern multiple
 193 times.
 194
 195 If a pattern starts with `#`, then it is treated as a comment, and
 196 will not match anything.  Use `\#` to match a literal `#` at the
 197 start of a line, or set the `nocomment` flag to suppress this behavior.
 198
 199 The double-star character `**` is supported by default, unless the
 200 `noglobstar` flag is set.  This is supported in the manner of bsdglob
 201 and bash 4.1, where `**` only has special significance if it is the only
 202 thing in a path part.  That is, `a/**/b` will match `a/x/y/b`, but
 203 `a/**b` will not.
 204
 205 If an escaped pattern has no matches, and the `nonull` flag is set,
 206 then minimatch.match returns the pattern as-provided, rather than
 207 interpreting the character escapes.  For example,
 208 `minimatch.match([], "\\*a\\?")` will return `"\\*a\\?"` rather than
 209 `"*a?"`.  This is akin to setting the `nullglob` option in bash, except
 210 that it does not resolve escaped pattern characters.
 211
 212 If brace expansion is not disabled, then it is performed before any
 213 other interpretation of the glob pattern.  Thus, a pattern like
 214 `+(a|{b),c)}`, which would not be valid in bash or zsh, is expanded
 215 **first** into the set of `+(a|b)` and `+(a|c)`, and those patterns are
 216 checked for validity.  Since those two are valid, matching proceeds.