pax_global_header00006660000000000000000000000064131062751470014520gustar00rootroot0000000000000052 comment=2fb3c84433eca2dc1d409527b917be58dbed7148 node-minimatch-3.0.4/000077500000000000000000000000001310627514700144205ustar00rootroot00000000000000node-minimatch-3.0.4/.gitignore000066400000000000000000000000311310627514700164020ustar00rootroot00000000000000node_modules .nyc_output node-minimatch-3.0.4/.npmignore000066400000000000000000000000171310627514700164150ustar00rootroot00000000000000# nothing here node-minimatch-3.0.4/.travis.yml000066400000000000000000000001151310627514700165260ustar00rootroot00000000000000sudo: false language: node_js node_js: - '0.10' - '0.12' - '4' - '5' node-minimatch-3.0.4/LICENSE000066400000000000000000000013751310627514700154330ustar00rootroot00000000000000The ISC License Copyright (c) Isaac Z. Schlueter and Contributors Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies. THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. node-minimatch-3.0.4/README.md000066400000000000000000000143001310627514700156750ustar00rootroot00000000000000# minimatch A minimal matching utility. [![Build Status](https://secure.travis-ci.org/isaacs/minimatch.svg)](http://travis-ci.org/isaacs/minimatch) This is the matching library used internally by npm. It works by converting glob expressions into JavaScript `RegExp` objects. ## Usage ```javascript var minimatch = require("minimatch") minimatch("bar.foo", "*.foo") // true! minimatch("bar.foo", "*.bar") // false! minimatch("bar.foo", "*.+(bar|foo)", { debug: true }) // true, and noisy! ``` ## Features Supports these glob features: * Brace Expansion * Extended glob matching * "Globstar" `**` matching See: * `man sh` * `man bash` * `man 3 fnmatch` * `man 5 gitignore` ## Minimatch Class Create a minimatch object by instantiating the `minimatch.Minimatch` class. ```javascript var Minimatch = require("minimatch").Minimatch var mm = new Minimatch(pattern, options) ``` ### Properties * `pattern` The original pattern the minimatch object represents. * `options` The options supplied to the constructor. * `set` A 2-dimensional array of regexp or string expressions. Each row in the array corresponds to a brace-expanded pattern. Each item in the row corresponds to a single path-part. For example, the pattern `{a,b/c}/d` would expand to a set of patterns like: [ [ a, d ] , [ b, c, d ] ] If a portion of the pattern doesn't have any "magic" in it (that is, it's something like `"foo"` rather than `fo*o?`), then it will be left as a string rather than converted to a regular expression. * `regexp` Created by the `makeRe` method. A single regular expression expressing the entire pattern. This is useful in cases where you wish to use the pattern somewhat like `fnmatch(3)` with `FNM_PATH` enabled. * `negate` True if the pattern is negated. * `comment` True if the pattern is a comment. * `empty` True if the pattern is `""`. ### Methods * `makeRe` Generate the `regexp` member if necessary, and return it. Will return `false` if the pattern is invalid. * `match(fname)` Return true if the filename matches the pattern, or false otherwise. * `matchOne(fileArray, patternArray, partial)` Take a `/`-split filename, and match it against a single row in the `regExpSet`. This method is mainly for internal use, but is exposed so that it can be used by a glob-walker that needs to avoid excessive filesystem calls. All other methods are internal, and will be called as necessary. ### minimatch(path, pattern, options) Main export. Tests a path against the pattern using the options. ```javascript var isJS = minimatch(file, "*.js", { matchBase: true }) ``` ### minimatch.filter(pattern, options) Returns a function that tests its supplied argument, suitable for use with `Array.filter`. Example: ```javascript var javascripts = fileList.filter(minimatch.filter("*.js", {matchBase: true})) ``` ### minimatch.match(list, pattern, options) Match against the list of files, in the style of fnmatch or glob. If nothing is matched, and options.nonull is set, then return a list containing the pattern itself. ```javascript var javascripts = minimatch.match(fileList, "*.js", {matchBase: true})) ``` ### minimatch.makeRe(pattern, options) Make a regular expression object from the pattern. ## Options All options are `false` by default. ### debug Dump a ton of stuff to stderr. ### nobrace Do not expand `{a,b}` and `{1..3}` brace sets. ### noglobstar Disable `**` matching against multiple folder names. ### dot Allow patterns to match filenames starting with a period, even if the pattern does not explicitly have a period in that spot. Note that by default, `a/**/b` will **not** match `a/.d/b`, unless `dot` is set. ### noext Disable "extglob" style patterns like `+(a|b)`. ### nocase Perform a case-insensitive match. ### nonull When a match is not found by `minimatch.match`, return a list containing the pattern itself if this option is set. When not set, an empty list is returned if there are no matches. ### matchBase If set, then patterns without slashes will be matched against the basename of the path if it contains slashes. For example, `a?b` would match the path `/xyz/123/acb`, but not `/xyz/acb/123`. ### nocomment Suppress the behavior of treating `#` at the start of a pattern as a comment. ### nonegate Suppress the behavior of treating a leading `!` character as negation. ### flipNegate Returns from negate expressions the same as if they were not negated. (Ie, true on a hit, false on a miss.) ## Comparisons to other fnmatch/glob implementations While strict compliance with the existing standards is a worthwhile goal, some discrepancies exist between minimatch and other implementations, and are intentional. If the pattern starts with a `!` character, then it is negated. Set the `nonegate` flag to suppress this behavior, and treat leading `!` characters normally. This is perhaps relevant if you wish to start the pattern with a negative extglob pattern like `!(a|B)`. Multiple `!` characters at the start of a pattern will negate the pattern multiple times. If a pattern starts with `#`, then it is treated as a comment, and will not match anything. Use `\#` to match a literal `#` at the start of a line, or set the `nocomment` flag to suppress this behavior. The double-star character `**` is supported by default, unless the `noglobstar` flag is set. This is supported in the manner of bsdglob and bash 4.1, where `**` only has special significance if it is the only thing in a path part. That is, `a/**/b` will match `a/x/y/b`, but `a/**b` will not. If an escaped pattern has no matches, and the `nonull` flag is set, then minimatch.match returns the pattern as-provided, rather than interpreting the character escapes. For example, `minimatch.match([], "\\*a\\?")` will return `"\\*a\\?"` rather than `"*a?"`. This is akin to setting the `nullglob` option in bash, except that it does not resolve escaped pattern characters. If brace expansion is not disabled, then it is performed before any other interpretation of the glob pattern. Thus, a pattern like `+(a|{b),c)}`, which would not be valid in bash or zsh, is expanded **first** into the set of `+(a|b)` and `+(a|c)`, and those patterns are checked for validity. Since those two are valid, matching proceeds. node-minimatch-3.0.4/benchmark.js000066400000000000000000000006571310627514700167200ustar00rootroot00000000000000var m = require('./minimatch.js') var pattern = '**/*.js' var expand = require('brace-expansion') var files = expand('x/y/z/{1..1000}.js') var start = process.hrtime() for (var i = 0; i < 1000; i++) { for (var f = 0; f < files.length; f++) { var res = m(pattern, files[f]) } if (!(i % 10)) process.stdout.write('.') } console.log('done') var dur = process.hrtime(start) console.log('%s ms', dur[0] * 1e3 + dur[1] / 1e6) node-minimatch-3.0.4/minimatch.js000066400000000000000000000614031310627514700167330ustar00rootroot00000000000000module.exports = minimatch minimatch.Minimatch = Minimatch var path = { sep: '/' } try { path = require('path') } catch (er) {} var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {} var expand = require('brace-expansion') var plTypes = { '!': { open: '(?:(?!(?:', close: '))[^/]*?)'}, '?': { open: '(?:', close: ')?' }, '+': { open: '(?:', close: ')+' }, '*': { open: '(?:', close: ')*' }, '@': { open: '(?:', close: ')' } } // any single thing other than / // don't need to escape / when using new RegExp() var qmark = '[^/]' // * => any number of characters var star = qmark + '*?' // ** when dots are allowed. Anything goes, except .. and . // not (^ or / followed by one or two dots followed by $ or /), // followed by anything, any number of times. var twoStarDot = '(?:(?!(?:\\\/|^)(?:\\.{1,2})($|\\\/)).)*?' // not a ^ or / followed by a dot, // followed by anything, any number of times. var twoStarNoDot = '(?:(?!(?:\\\/|^)\\.).)*?' // characters that need to be escaped in RegExp. var reSpecials = charSet('().*{}+?[]^$\\!') // "abc" -> { a:true, b:true, c:true } function charSet (s) { return s.split('').reduce(function (set, c) { set[c] = true return set }, {}) } // normalizes slashes. var slashSplit = /\/+/ minimatch.filter = filter function filter (pattern, options) { options = options || {} return function (p, i, list) { return minimatch(p, pattern, options) } } function ext (a, b) { a = a || {} b = b || {} var t = {} Object.keys(b).forEach(function (k) { t[k] = b[k] }) Object.keys(a).forEach(function (k) { t[k] = a[k] }) return t } minimatch.defaults = function (def) { if (!def || !Object.keys(def).length) return minimatch var orig = minimatch var m = function minimatch (p, pattern, options) { return orig.minimatch(p, pattern, ext(def, options)) } m.Minimatch = function Minimatch (pattern, options) { return new orig.Minimatch(pattern, ext(def, options)) } return m } Minimatch.defaults = function (def) { if (!def || !Object.keys(def).length) return Minimatch return minimatch.defaults(def).Minimatch } function minimatch (p, pattern, options) { if (typeof pattern !== 'string') { throw new TypeError('glob pattern string required') } if (!options) options = {} // shortcut: comments match nothing. if (!options.nocomment && pattern.charAt(0) === '#') { return false } // "" only matches "" if (pattern.trim() === '') return p === '' return new Minimatch(pattern, options).match(p) } function Minimatch (pattern, options) { if (!(this instanceof Minimatch)) { return new Minimatch(pattern, options) } if (typeof pattern !== 'string') { throw new TypeError('glob pattern string required') } if (!options) options = {} pattern = pattern.trim() // windows support: need to use /, not \ if (path.sep !== '/') { pattern = pattern.split(path.sep).join('/') } this.options = options this.set = [] this.pattern = pattern this.regexp = null this.negate = false this.comment = false this.empty = false // make the set of regexps etc. this.make() } Minimatch.prototype.debug = function () {} Minimatch.prototype.make = make function make () { // don't do it more than once. if (this._made) return var pattern = this.pattern var options = this.options // empty patterns and comments match nothing. if (!options.nocomment && pattern.charAt(0) === '#') { this.comment = true return } if (!pattern) { this.empty = true return } // step 1: figure out negation, etc. this.parseNegate() // step 2: expand braces var set = this.globSet = this.braceExpand() if (options.debug) this.debug = console.error this.debug(this.pattern, set) // step 3: now we have a set, so turn each one into a series of path-portion // matching patterns. // These will be regexps, except in the case of "**", which is // set to the GLOBSTAR object for globstar behavior, // and will not contain any / characters set = this.globParts = set.map(function (s) { return s.split(slashSplit) }) this.debug(this.pattern, set) // glob --> regexps set = set.map(function (s, si, set) { return s.map(this.parse, this) }, this) this.debug(this.pattern, set) // filter out everything that didn't compile properly. set = set.filter(function (s) { return s.indexOf(false) === -1 }) this.debug(this.pattern, set) this.set = set } Minimatch.prototype.parseNegate = parseNegate function parseNegate () { var pattern = this.pattern var negate = false var options = this.options var negateOffset = 0 if (options.nonegate) return for (var i = 0, l = pattern.length ; i < l && pattern.charAt(i) === '!' ; i++) { negate = !negate negateOffset++ } if (negateOffset) this.pattern = pattern.substr(negateOffset) this.negate = negate } // Brace expansion: // a{b,c}d -> abd acd // a{b,}c -> abc ac // a{0..3}d -> a0d a1d a2d a3d // a{b,c{d,e}f}g -> abg acdfg acefg // a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg // // Invalid sets are not expanded. // a{2..}b -> a{2..}b // a{b}c -> a{b}c minimatch.braceExpand = function (pattern, options) { return braceExpand(pattern, options) } Minimatch.prototype.braceExpand = braceExpand function braceExpand (pattern, options) { if (!options) { if (this instanceof Minimatch) { options = this.options } else { options = {} } } pattern = typeof pattern === 'undefined' ? this.pattern : pattern if (typeof pattern === 'undefined') { throw new TypeError('undefined pattern') } if (options.nobrace || !pattern.match(/\{.*\}/)) { // shortcut. no need to expand. return [pattern] } return expand(pattern) } // parse a component of the expanded set. // At this point, no pattern may contain "/" in it // so we're going to return a 2d array, where each entry is the full // pattern, split on '/', and then turned into a regular expression. // A regexp is made at the end which joins each array with an // escaped /, and another full one which joins each regexp with |. // // Following the lead of Bash 4.1, note that "**" only has special meaning // when it is the *only* thing in a path portion. Otherwise, any series // of * is equivalent to a single *. Globstar behavior is enabled by // default, and can be disabled by setting options.noglobstar. Minimatch.prototype.parse = parse var SUBPARSE = {} function parse (pattern, isSub) { if (pattern.length > 1024 * 64) { throw new TypeError('pattern is too long') } var options = this.options // shortcuts if (!options.noglobstar && pattern === '**') return GLOBSTAR if (pattern === '') return '' var re = '' var hasMagic = !!options.nocase var escaping = false // ? => one single character var patternListStack = [] var negativeLists = [] var stateChar var inClass = false var reClassStart = -1 var classStart = -1 // . and .. never match anything that doesn't start with ., // even when options.dot is set. var patternStart = pattern.charAt(0) === '.' ? '' // anything // not (start or / followed by . or .. followed by / or end) : options.dot ? '(?!(?:^|\\\/)\\.{1,2}(?:$|\\\/))' : '(?!\\.)' var self = this function clearStateChar () { if (stateChar) { // we had some state-tracking character // that wasn't consumed by this pass. switch (stateChar) { case '*': re += star hasMagic = true break case '?': re += qmark hasMagic = true break default: re += '\\' + stateChar break } self.debug('clearStateChar %j %j', stateChar, re) stateChar = false } } for (var i = 0, len = pattern.length, c ; (i < len) && (c = pattern.charAt(i)) ; i++) { this.debug('%s\t%s %s %j', pattern, i, re, c) // skip over any that are escaped. if (escaping && reSpecials[c]) { re += '\\' + c escaping = false continue } switch (c) { case '/': // completely not allowed, even escaped. // Should already be path-split by now. return false case '\\': clearStateChar() escaping = true continue // the various stateChar values // for the "extglob" stuff. case '?': case '*': case '+': case '@': case '!': this.debug('%s\t%s %s %j <-- stateChar', pattern, i, re, c) // all of those are literals inside a class, except that // the glob [!a] means [^a] in regexp if (inClass) { this.debug(' in class') if (c === '!' && i === classStart + 1) c = '^' re += c continue } // if we already have a stateChar, then it means // that there was something like ** or +? in there. // Handle the stateChar, then proceed with this one. self.debug('call clearStateChar %j', stateChar) clearStateChar() stateChar = c // if extglob is disabled, then +(asdf|foo) isn't a thing. // just clear the statechar *now*, rather than even diving into // the patternList stuff. if (options.noext) clearStateChar() continue case '(': if (inClass) { re += '(' continue } if (!stateChar) { re += '\\(' continue } patternListStack.push({ type: stateChar, start: i - 1, reStart: re.length, open: plTypes[stateChar].open, close: plTypes[stateChar].close }) // negation is (?:(?!js)[^/]*) re += stateChar === '!' ? '(?:(?!(?:' : '(?:' this.debug('plType %j %j', stateChar, re) stateChar = false continue case ')': if (inClass || !patternListStack.length) { re += '\\)' continue } clearStateChar() hasMagic = true var pl = patternListStack.pop() // negation is (?:(?!js)[^/]*) // The others are (?:) re += pl.close if (pl.type === '!') { negativeLists.push(pl) } pl.reEnd = re.length continue case '|': if (inClass || !patternListStack.length || escaping) { re += '\\|' escaping = false continue } clearStateChar() re += '|' continue // these are mostly the same in regexp and glob case '[': // swallow any state-tracking char before the [ clearStateChar() if (inClass) { re += '\\' + c continue } inClass = true classStart = i reClassStart = re.length re += c continue case ']': // a right bracket shall lose its special // meaning and represent itself in // a bracket expression if it occurs // first in the list. -- POSIX.2 2.8.3.2 if (i === classStart + 1 || !inClass) { re += '\\' + c escaping = false continue } // handle the case where we left a class open. // "[z-a]" is valid, equivalent to "\[z-a\]" if (inClass) { // split where the last [ was, make sure we don't have // an invalid re. if so, re-walk the contents of the // would-be class to re-translate any characters that // were passed through as-is // TODO: It would probably be faster to determine this // without a try/catch and a new RegExp, but it's tricky // to do safely. For now, this is safe and works. var cs = pattern.substring(classStart + 1, i) try { RegExp('[' + cs + ']') } catch (er) { // not a valid class! var sp = this.parse(cs, SUBPARSE) re = re.substr(0, reClassStart) + '\\[' + sp[0] + '\\]' hasMagic = hasMagic || sp[1] inClass = false continue } } // finish up the class. hasMagic = true inClass = false re += c continue default: // swallow any state char that wasn't consumed clearStateChar() if (escaping) { // no need escaping = false } else if (reSpecials[c] && !(c === '^' && inClass)) { re += '\\' } re += c } // switch } // for // handle the case where we left a class open. // "[abc" is valid, equivalent to "\[abc" if (inClass) { // split where the last [ was, and escape it // this is a huge pita. We now have to re-walk // the contents of the would-be class to re-translate // any characters that were passed through as-is cs = pattern.substr(classStart + 1) sp = this.parse(cs, SUBPARSE) re = re.substr(0, reClassStart) + '\\[' + sp[0] hasMagic = hasMagic || sp[1] } // handle the case where we had a +( thing at the *end* // of the pattern. // each pattern list stack adds 3 chars, and we need to go through // and escape any | chars that were passed through as-is for the regexp. // Go through and escape them, taking care not to double-escape any // | chars that were already escaped. for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) { var tail = re.slice(pl.reStart + pl.open.length) this.debug('setting tail', re, pl) // maybe some even number of \, then maybe 1 \, followed by a | tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, function (_, $1, $2) { if (!$2) { // the | isn't already escaped, so escape it. $2 = '\\' } // need to escape all those slashes *again*, without escaping the // one that we need for escaping the | character. As it works out, // escaping an even number of slashes can be done by simply repeating // it exactly after itself. That's why this trick works. // // I am sorry that you have to see this. return $1 + $1 + $2 + '|' }) this.debug('tail=%j\n %s', tail, tail, pl, re) var t = pl.type === '*' ? star : pl.type === '?' ? qmark : '\\' + pl.type hasMagic = true re = re.slice(0, pl.reStart) + t + '\\(' + tail } // handle trailing things that only matter at the very end. clearStateChar() if (escaping) { // trailing \\ re += '\\\\' } // only need to apply the nodot start if the re starts with // something that could conceivably capture a dot var addPatternStart = false switch (re.charAt(0)) { case '.': case '[': case '(': addPatternStart = true } // Hack to work around lack of negative lookbehind in JS // A pattern like: *.!(x).!(y|z) needs to ensure that a name // like 'a.xyz.yz' doesn't match. So, the first negative // lookahead, has to look ALL the way ahead, to the end of // the pattern. for (var n = negativeLists.length - 1; n > -1; n--) { var nl = negativeLists[n] var nlBefore = re.slice(0, nl.reStart) var nlFirst = re.slice(nl.reStart, nl.reEnd - 8) var nlLast = re.slice(nl.reEnd - 8, nl.reEnd) var nlAfter = re.slice(nl.reEnd) nlLast += nlAfter // Handle nested stuff like *(*.js|!(*.json)), where open parens // mean that we should *not* include the ) in the bit that is considered // "after" the negated section. var openParensBefore = nlBefore.split('(').length - 1 var cleanAfter = nlAfter for (i = 0; i < openParensBefore; i++) { cleanAfter = cleanAfter.replace(/\)[+*?]?/, '') } nlAfter = cleanAfter var dollar = '' if (nlAfter === '' && isSub !== SUBPARSE) { dollar = '$' } var newRe = nlBefore + nlFirst + nlAfter + dollar + nlLast re = newRe } // if the re is not "" at this point, then we need to make sure // it doesn't match against an empty path part. // Otherwise a/* will match a/, which it should not. if (re !== '' && hasMagic) { re = '(?=.)' + re } if (addPatternStart) { re = patternStart + re } // parsing just a piece of a larger pattern. if (isSub === SUBPARSE) { return [re, hasMagic] } // skip the regexp for non-magical patterns // unescape anything in it, though, so that it'll be // an exact match against a file etc. if (!hasMagic) { return globUnescape(pattern) } var flags = options.nocase ? 'i' : '' try { var regExp = new RegExp('^' + re + '$', flags) } catch (er) { // If it was an invalid regular expression, then it can't match // anything. This trick looks for a character after the end of // the string, which is of course impossible, except in multi-line // mode, but it's not a /m regex. return new RegExp('$.') } regExp._glob = pattern regExp._src = re return regExp } minimatch.makeRe = function (pattern, options) { return new Minimatch(pattern, options || {}).makeRe() } Minimatch.prototype.makeRe = makeRe function makeRe () { if (this.regexp || this.regexp === false) return this.regexp // at this point, this.set is a 2d array of partial // pattern strings, or "**". // // It's better to use .match(). This function shouldn't // be used, really, but it's pretty convenient sometimes, // when you just want to work with a regex. var set = this.set if (!set.length) { this.regexp = false return this.regexp } var options = this.options var twoStar = options.noglobstar ? star : options.dot ? twoStarDot : twoStarNoDot var flags = options.nocase ? 'i' : '' var re = set.map(function (pattern) { return pattern.map(function (p) { return (p === GLOBSTAR) ? twoStar : (typeof p === 'string') ? regExpEscape(p) : p._src }).join('\\\/') }).join('|') // must match entire pattern // ending in a * or ** will make it less strict. re = '^(?:' + re + ')$' // can match anything, as long as it's not this. if (this.negate) re = '^(?!' + re + ').*$' try { this.regexp = new RegExp(re, flags) } catch (ex) { this.regexp = false } return this.regexp } minimatch.match = function (list, pattern, options) { options = options || {} var mm = new Minimatch(pattern, options) list = list.filter(function (f) { return mm.match(f) }) if (mm.options.nonull && !list.length) { list.push(pattern) } return list } Minimatch.prototype.match = match function match (f, partial) { this.debug('match', f, this.pattern) // short-circuit in the case of busted things. // comments, etc. if (this.comment) return false if (this.empty) return f === '' if (f === '/' && partial) return true var options = this.options // windows: need to use /, not \ if (path.sep !== '/') { f = f.split(path.sep).join('/') } // treat the test path as a set of pathparts. f = f.split(slashSplit) this.debug(this.pattern, 'split', f) // just ONE of the pattern sets in this.set needs to match // in order for it to be valid. If negating, then just one // match means that we have failed. // Either way, return on the first hit. var set = this.set this.debug(this.pattern, 'set', set) // Find the basename of the path by looking for the last non-empty segment var filename var i for (i = f.length - 1; i >= 0; i--) { filename = f[i] if (filename) break } for (i = 0; i < set.length; i++) { var pattern = set[i] var file = f if (options.matchBase && pattern.length === 1) { file = [filename] } var hit = this.matchOne(file, pattern, partial) if (hit) { if (options.flipNegate) return true return !this.negate } } // didn't get any hits. this is success if it's a negative // pattern, failure otherwise. if (options.flipNegate) return false return this.negate } // set partial to true to test if, for example, // "/a/b" matches the start of "/*/b/*/d" // Partial means, if you run out of file before you run // out of pattern, then that's fine, as long as all // the parts match. Minimatch.prototype.matchOne = function (file, pattern, partial) { var options = this.options this.debug('matchOne', { 'this': this, file: file, pattern: pattern }) this.debug('matchOne', file.length, pattern.length) for (var fi = 0, pi = 0, fl = file.length, pl = pattern.length ; (fi < fl) && (pi < pl) ; fi++, pi++) { this.debug('matchOne loop') var p = pattern[pi] var f = file[fi] this.debug(pattern, p, f) // should be impossible. // some invalid regexp stuff in the set. if (p === false) return false if (p === GLOBSTAR) { this.debug('GLOBSTAR', [pattern, p, f]) // "**" // a/**/b/**/c would match the following: // a/b/x/y/z/c // a/x/y/z/b/c // a/b/x/b/x/c // a/b/c // To do this, take the rest of the pattern after // the **, and see if it would match the file remainder. // If so, return success. // If not, the ** "swallows" a segment, and try again. // This is recursively awful. // // a/**/b/**/c matching a/b/x/y/z/c // - a matches a // - doublestar // - matchOne(b/x/y/z/c, b/**/c) // - b matches b // - doublestar // - matchOne(x/y/z/c, c) -> no // - matchOne(y/z/c, c) -> no // - matchOne(z/c, c) -> no // - matchOne(c, c) yes, hit var fr = fi var pr = pi + 1 if (pr === pl) { this.debug('** at the end') // a ** at the end will just swallow the rest. // We have found a match. // however, it will not swallow /.x, unless // options.dot is set. // . and .. are *never* matched by **, for explosively // exponential reasons. for (; fi < fl; fi++) { if (file[fi] === '.' || file[fi] === '..' || (!options.dot && file[fi].charAt(0) === '.')) return false } return true } // ok, let's see if we can swallow whatever we can. while (fr < fl) { var swallowee = file[fr] this.debug('\nglobstar while', file, fr, pattern, pr, swallowee) // XXX remove this slice. Just pass the start index. if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) { this.debug('globstar found match!', fr, fl, swallowee) // found a match. return true } else { // can't swallow "." or ".." ever. // can only swallow ".foo" when explicitly asked. if (swallowee === '.' || swallowee === '..' || (!options.dot && swallowee.charAt(0) === '.')) { this.debug('dot detected!', file, fr, pattern, pr) break } // ** swallows a segment, and continue. this.debug('globstar swallow a segment, and continue') fr++ } } // no match was found. // However, in partial mode, we can't say this is necessarily over. // If there's more *pattern* left, then if (partial) { // ran out of file this.debug('\n>>> no match, partial?', file, fr, pattern, pr) if (fr === fl) return true } return false } // something other than ** // non-magic patterns just have to match exactly // patterns with magic have been turned into regexps. var hit if (typeof p === 'string') { if (options.nocase) { hit = f.toLowerCase() === p.toLowerCase() } else { hit = f === p } this.debug('string match', p, f, hit) } else { hit = f.match(p) this.debug('pattern match', p, f, hit) } if (!hit) return false } // Note: ending in / means that we'll get a final "" // at the end of the pattern. This can only match a // corresponding "" at the end of the file. // If the file ends in /, then it can only match a // a pattern that ends in /, unless the pattern just // doesn't have any more for it. But, a/b/ should *not* // match "a/b/*", even though "" matches against the // [^/]*? pattern, except in partial mode, where it might // simply not be reached yet. // However, a/b/ should still satisfy a/* // now either we fell off the end of the pattern, or we're done. if (fi === fl && pi === pl) { // ran out of pattern and filename at the same time. // an exact hit! return true } else if (fi === fl) { // ran out of file, but still had pattern left. // this is ok if we're doing the match as part of // a glob fs traversal. return partial } else if (pi === pl) { // ran out of pattern, still have file left. // this is only acceptable if we're on the very last // empty segment of a file with a trailing slash. // a/* should match a/b/ var emptyFileEnd = (fi === fl - 1) && (file[fi] === '') return emptyFileEnd } // should be unreachable. throw new Error('wtf?') } // replace stuff like \* with * function globUnescape (s) { return s.replace(/\\(.)/g, '$1') } function regExpEscape (s) { return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&') } node-minimatch-3.0.4/package-lock.json000066400000000000000000000012351310627514700176350ustar00rootroot00000000000000{ "name": "minimatch", "version": "3.0.4", "dependencies": { "balanced-match": { "version": "0.4.2", "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-0.4.2.tgz", "integrity": "sha1-yz8+PHMtwPAe5wtAPzAuYddwmDg=" }, "brace-expansion": { "version": "1.1.7", "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.7.tgz", "integrity": "sha1-Pv/DxQ4ABTH7cg6v+A8K6O8jz1k=" }, "concat-map": { "version": "0.0.1", "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=" } } } node-minimatch-3.0.4/package.json000066400000000000000000000012331310627514700167050ustar00rootroot00000000000000{ "author": "Isaac Z. Schlueter (http://blog.izs.me)", "name": "minimatch", "description": "a glob matcher in javascript", "version": "3.0.4", "repository": { "type": "git", "url": "git://github.com/isaacs/minimatch.git" }, "main": "minimatch.js", "scripts": { "test": "tap test/*.js --cov", "preversion": "npm test", "postversion": "npm publish", "postpublish": "git push origin --all; git push origin --tags" }, "engines": { "node": "*" }, "dependencies": { "brace-expansion": "^1.1.7" }, "devDependencies": { "tap": "^10.3.2" }, "license": "ISC", "files": [ "minimatch.js" ] } node-minimatch-3.0.4/test/000077500000000000000000000000001310627514700153775ustar00rootroot00000000000000node-minimatch-3.0.4/test/basic.js000066400000000000000000000035741310627514700170270ustar00rootroot00000000000000// http://www.bashcookbook.com/bashinfo/source/bash-1.14.7/tests/glob-test // // TODO: Some of these tests do very bad things with backslashes, and will // most likely fail badly on windows. They should probably be skipped. var tap = require('tap') var globalBefore = Object.keys(global) var mm = require('../') var patterns = require('./patterns.js') var regexps = patterns.regexps var re = 0 tap.test('basic tests', function (t) { var start = Date.now() // [ pattern, [matches], MM opts, files, TAP opts] patterns.forEach(function (c) { if (typeof c === 'function') return c() if (typeof c === 'string') return t.comment(c) var pattern = c[0], expect = c[1].sort(alpha), options = c[2] || {}, f = c[3] || patterns.files, tapOpts = c[4] || {} // options.debug = true var m = new mm.Minimatch(pattern, options) var r = m.makeRe() var expectRe = regexps[re++] expectRe = '/' + expectRe.slice(1, -1).replace(new RegExp('([^\\\\])/', 'g'), '$1\\\/') + '/' tapOpts.re = String(r) || JSON.stringify(r) tapOpts.re = '/' + tapOpts.re.slice(1, -1).replace(new RegExp('([^\\\\])/', 'g'), '$1\\\/') + '/' tapOpts.files = JSON.stringify(f) tapOpts.pattern = pattern tapOpts.set = m.set tapOpts.negated = m.negate var actual = mm.match(f, pattern, options) actual.sort(alpha) t.equivalent( actual, expect, JSON.stringify(pattern) + ' ' + JSON.stringify(expect), tapOpts ) t.equal(tapOpts.re, expectRe, null, tapOpts) }) t.comment('time=' + (Date.now() - start) + 'ms') t.end() }) tap.test('global leak test', function (t) { var globalAfter = Object.keys(global).filter(function (k) { return (k !== '__coverage__' && k !== '__core-js_shared__') }) t.equivalent(globalAfter, globalBefore, 'no new globals, please') t.end() }) function alpha (a, b) { return a > b ? 1 : -1 } node-minimatch-3.0.4/test/brace-expand.js000066400000000000000000000023561310627514700202740ustar00rootroot00000000000000var tap = require('tap'), minimatch = require('../') tap.test('brace expansion', function (t) { // [ pattern, [expanded] ] var patterns = [ [ 'a{b,c{d,e},{f,g}h}x{y,z}', [ 'abxy', 'abxz', 'acdxy', 'acdxz', 'acexy', 'acexz', 'afhxy', 'afhxz', 'aghxy', 'aghxz' ] ], [ 'a{1..5}b', [ 'a1b', 'a2b', 'a3b', 'a4b', 'a5b' ] ], ['a{b}c', ['a{b}c']], [ 'a{00..05}b', [ 'a00b', 'a01b', 'a02b', 'a03b', 'a04b', 'a05b' ] ], ['z{a,b},c}d', ['za,c}d', 'zb,c}d']], ['z{a,b{,c}d', ['z{a,bd', 'z{a,bcd']], ['a{b{c{d,e}f}g}h', ['a{b{cdf}g}h', 'a{b{cef}g}h']], [ 'a{b{c{d,e}f{x,y}}g}h', [ 'a{b{cdfx}g}h', 'a{b{cdfy}g}h', 'a{b{cefx}g}h', 'a{b{cefy}g}h' ] ], [ 'a{b{c{d,e}f{x,y{}g}h', [ 'a{b{cdfxh', 'a{b{cdfy{}gh', 'a{b{cefxh', 'a{b{cefy{}gh' ] ] ] patterns.forEach(function (tc) { var p = tc[0], expect = tc[1] t.equivalent(minimatch.braceExpand(p), expect, p) }) t.end() }) node-minimatch-3.0.4/test/defaults.js000066400000000000000000000031011310627514700175370ustar00rootroot00000000000000// http://www.bashcookbook.com/bashinfo/source/bash-1.14.7/tests/glob-test // // TODO: Some of these tests do very bad things with backslashes, and will // most likely fail badly on windows. They should probably be skipped. var tap = require('tap') var globalBefore = Object.keys(global) var mm = require('../') var patterns = require('./patterns.js') tap.test('basic tests', function (t) { var start = Date.now() // [ pattern, [matches], MM opts, files, TAP opts] patterns.forEach(function (c) { if (typeof c === 'function') return c() if (typeof c === 'string') return t.comment(c) var pattern = c[0] var expect = c[1].sort(alpha) var options = c[2] var f = c[3] || patterns.files var tapOpts = c[4] || {} // options.debug = true var Class = mm.defaults(options).Minimatch var m = new Class(pattern, {}) var r = m.makeRe() tapOpts.re = String(r) || JSON.stringify(r) tapOpts.files = JSON.stringify(f) tapOpts.pattern = pattern tapOpts.set = m.set tapOpts.negated = m.negate var actual = mm.match(f, pattern, options) actual.sort(alpha) t.equivalent( actual, expect, JSON.stringify(pattern) + ' ' + JSON.stringify(expect), tapOpts ) }) t.comment('time=' + (Date.now() - start) + 'ms') t.end() }) tap.test('global leak test', function (t) { var globalAfter = Object.keys(global).filter(function (k) { return (k !== '__coverage__') }) t.equivalent(globalAfter, globalBefore, 'no new globals, please') t.end() }) function alpha (a, b) { return a > b ? 1 : -1 } node-minimatch-3.0.4/test/extglob-ending-with-state-char.js000066400000000000000000000003111310627514700236400ustar00rootroot00000000000000var test = require('tap').test var minimatch = require('../') test('extglob ending with statechar', function (t) { t.notOk(minimatch('ax', 'a?(b*)')) t.ok(minimatch('ax', '?(a*|b)')) t.end() }) node-minimatch-3.0.4/test/extglob-unfinished.js000066400000000000000000000004571310627514700215410ustar00rootroot00000000000000var t = require('tap') var mm = require('../') var types = '!?+*@'.split('') t.plan(types.length) types.forEach(function (type) { t.test(type, function (t) { t.plan(2) t.ok(mm(type + '(a|B', type + '(a|B', { nonegate: true })) t.notOk(mm(type + '(a|B', 'B', { nonegate: true })) }) }) node-minimatch-3.0.4/test/patterns.js000066400000000000000000000314561310627514700176060ustar00rootroot00000000000000if (module === require.main) { console.log('1..1\nok') } var files = [ 'a', 'b', 'c', 'd', 'abc', 'abd', 'abe', 'bb', 'bcd', 'ca', 'cb', 'dd', 'de', 'bdir/', 'bdir/cfile' ] module.exports = [ 'http://www.bashcookbook.com/bashinfo/source/bash-1.14.7/tests/glob-test', ['a*', ['a', 'abc', 'abd', 'abe']], ['X*', ['X*'], {nonull: true}], // allow null glob expansion ['X*', []], // isaacs: Slightly different than bash/sh/ksh // \\* is not un-escaped to literal "*" in a failed match, // but it does make it get treated as a literal star ['\\*', ['\\*'], {nonull: true}], ['\\**', ['\\**'], {nonull: true}], ['\\*\\*', ['\\*\\*'], {nonull: true}], ['b*/', ['bdir/']], ['c*', ['c', 'ca', 'cb']], ['**', files], ['\\.\\./*/', ['\\.\\./*/'], {nonull: true}], ['s/\\..*//', ['s/\\..*//'], {nonull: true}], 'legendary larry crashes bashes', ['/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*$/\\1/', ['/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*$/\\1/'], {nonull: true}], ['/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*$/\u0001/', ['/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*$/\u0001/'], {nonull: true}], 'character classes', ['[a-c]b*', ['abc', 'abd', 'abe', 'bb', 'cb']], ['[a-y]*[^c]', ['abd', 'abe', 'bb', 'bcd', 'bdir/', 'ca', 'cb', 'dd', 'de']], ['a*[^c]', ['abd', 'abe']], function () { files.push('a-b', 'aXb') }, ['a[X-]b', ['a-b', 'aXb']], function () { files.push('.x', '.y') }, ['[^a-c]*', ['d', 'dd', 'de']], function () { files.push('a*b/', 'a*b/ooo') }, ['a\\*b/*', ['a*b/ooo']], ['a\\*?/*', ['a*b/ooo']], ['*\\\\!*', [], {null: true}, ['echo !7']], ['*\\!*', ['echo !7'], null, ['echo !7']], ['*.\\*', ['r.*'], null, ['r.*']], ['a[b]c', ['abc']], ['a[\\b]c', ['abc']], ['a?c', ['abc']], ['a\\*c', [], {null: true}, ['abc']], ['', [''], { null: true }, ['']], 'http://www.opensource.apple.com/source/bash/bash-23/' + 'bash/tests/glob-test', function () { files.push('man/', 'man/man1/', 'man/man1/bash.1') }, ['*/man*/bash.*', ['man/man1/bash.1']], ['man/man1/bash.1', ['man/man1/bash.1']], ['a***c', ['abc'], null, ['abc']], ['a*****?c', ['abc'], null, ['abc']], ['?*****??', ['abc'], null, ['abc']], ['*****??', ['abc'], null, ['abc']], ['?*****?c', ['abc'], null, ['abc']], ['?***?****c', ['abc'], null, ['abc']], ['?***?****?', ['abc'], null, ['abc']], ['?***?****', ['abc'], null, ['abc']], ['*******c', ['abc'], null, ['abc']], ['*******?', ['abc'], null, ['abc']], ['a*cd**?**??k', ['abcdecdhjk'], null, ['abcdecdhjk']], ['a**?**cd**?**??k', ['abcdecdhjk'], null, ['abcdecdhjk']], ['a**?**cd**?**??k***', ['abcdecdhjk'], null, ['abcdecdhjk']], ['a**?**cd**?**??***k', ['abcdecdhjk'], null, ['abcdecdhjk']], ['a**?**cd**?**??***k**', ['abcdecdhjk'], null, ['abcdecdhjk']], ['a****c**?**??*****', ['abcdecdhjk'], null, ['abcdecdhjk']], ['[-abc]', ['-'], null, ['-']], ['[abc-]', ['-'], null, ['-']], ['\\', ['\\'], null, ['\\']], ['[\\\\]', ['\\'], null, ['\\']], ['[[]', ['['], null, ['[']], ['[', ['['], null, ['[']], ['[*', ['[abc'], null, ['[abc']], 'a right bracket shall lose its special meaning and\n' + 'represent itself in a bracket expression if it occurs\n' + 'first in the list. -- POSIX.2 2.8.3.2', ['[]]', [']'], null, [']']], ['[]-]', [']'], null, [']']], ['[a-\z]', ['p'], null, ['p']], ['??**********?****?', [], { null: true }, ['abc']], ['??**********?****c', [], { null: true }, ['abc']], ['?************c****?****', [], { null: true }, ['abc']], ['*c*?**', [], { null: true }, ['abc']], ['a*****c*?**', [], { null: true }, ['abc']], ['a********???*******', [], { null: true }, ['abc']], ['[]', [], { null: true }, ['a']], ['[abc', [], { null: true }, ['[']], 'nocase tests', ['XYZ', ['xYz'], { nocase: true, null: true }, ['xYz', 'ABC', 'IjK']], [ 'ab*', ['ABC'], { nocase: true, null: true }, ['xYz', 'ABC', 'IjK'] ], [ '[ia]?[ck]', ['ABC', 'IjK'], { nocase: true, null: true }, ['xYz', 'ABC', 'IjK'] ], // [ pattern, [matches], MM opts, files, TAP opts] 'onestar/twostar', ['{/*,*}', [], {null: true}, ['/asdf/asdf/asdf']], ['{/?,*}', ['/a', 'bb'], {null: true}, ['/a', '/b/b', '/a/b/c', 'bb']], 'dots should not match unless requested', ['**', ['a/b'], {}, ['a/b', 'a/.d', '.a/.d']], // .. and . can only match patterns starting with ., // even when options.dot is set. function () { files = ['a/./b', 'a/../b', 'a/c/b', 'a/.d/b'] }, ['a/*/b', ['a/c/b', 'a/.d/b'], {dot: true}], ['a/.*/b', ['a/./b', 'a/../b', 'a/.d/b'], {dot: true}], ['a/*/b', ['a/c/b'], {dot: false}], ['a/.*/b', ['a/./b', 'a/../b', 'a/.d/b'], {dot: false}], // this also tests that changing the options needs // to change the cache key, even if the pattern is // the same! [ '**', ['a/b', 'a/.d', '.a/.d'], { dot: true }, [ '.a/.d', 'a/.d', 'a/b'] ], 'paren sets cannot contain slashes', ['*(a/b)', ['*(a/b)'], {nonull: true}, ['a/b']], // brace sets trump all else. // // invalid glob pattern. fails on bash4 and bsdglob. // however, in this implementation, it's easier just // to do the intuitive thing, and let brace-expansion // actually come before parsing any extglob patterns, // like the documentation seems to say. // // XXX: if anyone complains about this, either fix it // or tell them to grow up and stop complaining. // // bash/bsdglob says this: // , ["*(a|{b),c)}", ["*(a|{b),c)}"], {}, ["a", "ab", "ac", "ad"]] // but we do this instead: ['*(a|{b),c)}', ['a', 'ab', 'ac'], {}, ['a', 'ab', 'ac', 'ad']], // test partial parsing in the presence of comment/negation chars ['[!a*', ['[!ab'], {}, ['[!ab', '[ab']], ['[#a*', ['[#ab'], {}, ['[#ab', '[ab']], // like: {a,b|c\\,d\\\|e} except it's unclosed, so it has to be escaped. [ '+(a|*\\|c\\\\|d\\\\\\|e\\\\\\\\|f\\\\\\\\\\|g', ['+(a|b\\|c\\\\|d\\\\|e\\\\\\\\|f\\\\\\\\|g'], {}, ['+(a|b\\|c\\\\|d\\\\|e\\\\\\\\|f\\\\\\\\|g', 'a', 'b\\c'] ], // crazy nested {,,} and *(||) tests. function () { files = [ 'a', 'b', 'c', 'd', 'ab', 'ac', 'ad', 'bc', 'cb', 'bc,d', 'c,db', 'c,d', 'd)', '(b|c', '*(b|c', 'b|c', 'b|cc', 'cb|c', 'x(a|b|c)', 'x(a|c)', '(a|b|c)', '(a|c)' ] }, ['*(a|{b,c})', ['a', 'b', 'c', 'ab', 'ac']], ['{a,*(b|c,d)}', ['a', '(b|c', '*(b|c', 'd)']], // a // *(b|c) // *(b|d) ['{a,*(b|{c,d})}', ['a', 'b', 'bc', 'cb', 'c', 'd']], ['*(a|{b|c,c})', ['a', 'b', 'c', 'ab', 'ac', 'bc', 'cb']], // test various flag settings. [ '*(a|{b|c,c})', ['x(a|b|c)', 'x(a|c)', '(a|b|c)', '(a|c)'], { noext: true } ], [ 'a?b', ['x/y/acb', 'acb/'], {matchBase: true}, ['x/y/acb', 'acb/', 'acb/d/e', 'x/y/acb/d'] ], ['#*', ['#a', '#b'], {nocomment: true}, ['#a', '#b', 'c#d']], // begin channelling Boole and deMorgan... 'negation tests', function () { files = ['d', 'e', '!ab', '!abc', 'a!b', '\\!a'] }, // anything that is NOT a* matches. ['!a*', ['\\!a', 'd', 'e', '!ab', '!abc']], // anything that IS !a* matches. ['!a*', ['!ab', '!abc'], {nonegate: true}], // anything that IS a* matches ['!!a*', ['a!b']], // anything that is NOT !a* matches ['!\\!a*', ['a!b', 'd', 'e', '\\!a']], // negation nestled within a pattern function () { files = [ 'foo.js', 'foo.bar', 'foo.js.js', 'blar.js', 'foo.', 'boo.js.boo' ] }, // last one is tricky! * matches foo, . matches ., and 'js.js' != 'js' // copy bash 4.3 behavior on this. ['*.!(js)', ['foo.bar', 'foo.', 'boo.js.boo', 'foo.js.js'] ], 'https://github.com/isaacs/minimatch/issues/5', function () { files = [ 'a/b/.x/c', 'a/b/.x/c/d', 'a/b/.x/c/d/e', 'a/b/.x', 'a/b/.x/', 'a/.x/b', '.x', '.x/', '.x/a', '.x/a/b', 'a/.x/b/.x/c', '.x/.x' ] }, [ '**/.x/**', [ '.x/', '.x/a', '.x/a/b', 'a/.x/b', 'a/b/.x/', 'a/b/.x/c', 'a/b/.x/c/d', 'a/b/.x/c/d/e' ] ], 'https://github.com/isaacs/minimatch/issues/59', ['[z-a]', []], ['a/[2015-03-10T00:23:08.647Z]/z', []], ['[a-0][a-\u0100]', []] ] module.exports.regexps = [ '/^(?:(?=.)a[^/]*?)$/', '/^(?:(?=.)X[^/]*?)$/', '/^(?:(?=.)X[^/]*?)$/', '/^(?:\\*)$/', '/^(?:(?=.)\\*[^/]*?)$/', '/^(?:\\*\\*)$/', '/^(?:(?=.)b[^/]*?\\/)$/', '/^(?:(?=.)c[^/]*?)$/', '/^(?:(?:(?!(?:\\/|^)\\.).)*?)$/', '/^(?:\\.\\.\\/(?!\\.)(?=.)[^/]*?\\/)$/', '/^(?:s\\/(?=.)\\.\\.[^/]*?\\/)$/', '/^(?:\\/\\^root:\\/\\{s\\/(?=.)\\^[^:][^/]*?:[^:][^/]*?:\\([^:]\\)[^/]*?\\.[^/]*?\\$\\/1\\/)$/', '/^(?:\\/\\^root:\\/\\{s\\/(?=.)\\^[^:][^/]*?:[^:][^/]*?:\\([^:]\\)[^/]*?\\.[^/]*?\\$\\/\u0001\\/)$/', '/^(?:(?!\\.)(?=.)[a-c]b[^/]*?)$/', '/^(?:(?!\\.)(?=.)[a-y][^/]*?[^c])$/', '/^(?:(?=.)a[^/]*?[^c])$/', '/^(?:(?=.)a[X-]b)$/', '/^(?:(?!\\.)(?=.)[^a-c][^/]*?)$/', '/^(?:a\\*b\\/(?!\\.)(?=.)[^/]*?)$/', '/^(?:(?=.)a\\*[^/]\\/(?!\\.)(?=.)[^/]*?)$/', '/^(?:(?!\\.)(?=.)[^/]*?\\\\\\![^/]*?)$/', '/^(?:(?!\\.)(?=.)[^/]*?\\![^/]*?)$/', '/^(?:(?!\\.)(?=.)[^/]*?\\.\\*)$/', '/^(?:(?=.)a[b]c)$/', '/^(?:(?=.)a[b]c)$/', '/^(?:(?=.)a[^/]c)$/', '/^(?:a\\*c)$/', 'false', '/^(?:(?!\\.)(?=.)[^/]*?\\/(?=.)man[^/]*?\\/(?=.)bash\\.[^/]*?)$/', '/^(?:man\\/man1\\/bash\\.1)$/', '/^(?:(?=.)a[^/]*?[^/]*?[^/]*?c)$/', '/^(?:(?=.)a[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]c)$/', '/^(?:(?!\\.)(?=.)[^/][^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/][^/])$/', '/^(?:(?!\\.)(?=.)[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/][^/])$/', '/^(?:(?!\\.)(?=.)[^/][^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]c)$/', '/^(?:(?!\\.)(?=.)[^/][^/]*?[^/]*?[^/]*?[^/][^/]*?[^/]*?[^/]*?[^/]*?c)$/', '/^(?:(?!\\.)(?=.)[^/][^/]*?[^/]*?[^/]*?[^/][^/]*?[^/]*?[^/]*?[^/]*?[^/])$/', '/^(?:(?!\\.)(?=.)[^/][^/]*?[^/]*?[^/]*?[^/][^/]*?[^/]*?[^/]*?[^/]*?)$/', '/^(?:(?!\\.)(?=.)[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?c)$/', '/^(?:(?!\\.)(?=.)[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/])$/', '/^(?:(?=.)a[^/]*?cd[^/]*?[^/]*?[^/][^/]*?[^/]*?[^/][^/]k)$/', '/^(?:(?=.)a[^/]*?[^/]*?[^/][^/]*?[^/]*?cd[^/]*?[^/]*?[^/][^/]*?[^/]*?[^/][^/]k)$/', '/^(?:(?=.)a[^/]*?[^/]*?[^/][^/]*?[^/]*?cd[^/]*?[^/]*?[^/][^/]*?[^/]*?[^/][^/]k[^/]*?[^/]*?[^/]*?)$/', '/^(?:(?=.)a[^/]*?[^/]*?[^/][^/]*?[^/]*?cd[^/]*?[^/]*?[^/][^/]*?[^/]*?[^/][^/][^/]*?[^/]*?[^/]*?k)$/', '/^(?:(?=.)a[^/]*?[^/]*?[^/][^/]*?[^/]*?cd[^/]*?[^/]*?[^/][^/]*?[^/]*?[^/][^/][^/]*?[^/]*?[^/]*?k[^/]*?[^/]*?)$/', '/^(?:(?=.)a[^/]*?[^/]*?[^/]*?[^/]*?c[^/]*?[^/]*?[^/][^/]*?[^/]*?[^/][^/][^/]*?[^/]*?[^/]*?[^/]*?[^/]*?)$/', '/^(?:(?!\\.)(?=.)[-abc])$/', '/^(?:(?!\\.)(?=.)[abc-])$/', '/^(?:\\\\)$/', '/^(?:(?!\\.)(?=.)[\\\\])$/', '/^(?:(?!\\.)(?=.)[\\[])$/', '/^(?:\\[)$/', '/^(?:(?=.)\\[(?!\\.)(?=.)[^/]*?)$/', '/^(?:(?!\\.)(?=.)[\\]])$/', '/^(?:(?!\\.)(?=.)[\\]-])$/', '/^(?:(?!\\.)(?=.)[a-z])$/', '/^(?:(?!\\.)(?=.)[^/][^/][^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/][^/]*?[^/]*?[^/]*?[^/]*?[^/])$/', '/^(?:(?!\\.)(?=.)[^/][^/][^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/][^/]*?[^/]*?[^/]*?[^/]*?c)$/', '/^(?:(?!\\.)(?=.)[^/][^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?c[^/]*?[^/]*?[^/]*?[^/]*?[^/][^/]*?[^/]*?[^/]*?[^/]*?)$/', '/^(?:(?!\\.)(?=.)[^/]*?c[^/]*?[^/][^/]*?[^/]*?)$/', '/^(?:(?=.)a[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?c[^/]*?[^/][^/]*?[^/]*?)$/', '/^(?:(?=.)a[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/][^/][^/][^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?)$/', '/^(?:\\[\\])$/', '/^(?:\\[abc)$/', '/^(?:(?=.)XYZ)$/i', '/^(?:(?=.)ab[^/]*?)$/i', '/^(?:(?!\\.)(?=.)[ia][^/][ck])$/i', '/^(?:\\/(?!\\.)(?=.)[^/]*?|(?!\\.)(?=.)[^/]*?)$/', '/^(?:\\/(?!\\.)(?=.)[^/]|(?!\\.)(?=.)[^/]*?)$/', '/^(?:(?:(?!(?:\\/|^)\\.).)*?)$/', '/^(?:a\\/(?!(?:^|\\/)\\.{1,2}(?:$|\\/))(?=.)[^/]*?\\/b)$/', '/^(?:a\\/(?=.)\\.[^/]*?\\/b)$/', '/^(?:a\\/(?!\\.)(?=.)[^/]*?\\/b)$/', '/^(?:a\\/(?=.)\\.[^/]*?\\/b)$/', '/^(?:(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?)$/', '/^(?:(?!\\.)(?=.)[^/]*?\\(a\\/b\\))$/', '/^(?:(?!\\.)(?=.)(?:a|b)*|(?!\\.)(?=.)(?:a|c)*)$/', '/^(?:(?=.)\\[(?=.)\\!a[^/]*?)$/', '/^(?:(?=.)\\[(?=.)#a[^/]*?)$/', '/^(?:(?=.)\\+\\(a\\|[^/]*?\\|c\\\\\\\\\\|d\\\\\\\\\\|e\\\\\\\\\\\\\\\\\\|f\\\\\\\\\\\\\\\\\\|g)$/', '/^(?:(?!\\.)(?=.)(?:a|b)*|(?!\\.)(?=.)(?:a|c)*)$/', '/^(?:a|(?!\\.)(?=.)[^/]*?\\(b\\|c|d\\))$/', '/^(?:a|(?!\\.)(?=.)(?:b|c)*|(?!\\.)(?=.)(?:b|d)*)$/', '/^(?:(?!\\.)(?=.)(?:a|b|c)*|(?!\\.)(?=.)(?:a|c)*)$/', '/^(?:(?!\\.)(?=.)[^/]*?\\(a\\|b\\|c\\)|(?!\\.)(?=.)[^/]*?\\(a\\|c\\))$/', '/^(?:(?=.)a[^/]b)$/', '/^(?:(?=.)#[^/]*?)$/', '/^(?!^(?:(?=.)a[^/]*?)$).*$/', '/^(?:(?=.)\\!a[^/]*?)$/', '/^(?:(?=.)a[^/]*?)$/', '/^(?!^(?:(?=.)\\!a[^/]*?)$).*$/', '/^(?:(?!\\.)(?=.)[^\\/]*?\\.(?:(?!(?:js)$)[^\\/]*?))$/', '/^(?:(?:(?!(?:\\/|^)\\.).)*?\\/\\.x\\/(?:(?!(?:\\/|^)\\.).)*?)$/', '/^(?:\\[z\\-a\\])$/', '/^(?:a\\/\\[2015\\-03\\-10T00:23:08\\.647Z\\]\\/z)$/', '/^(?:(?=.)\\[a-0\\][a-Ā])$/' ] Object.defineProperty(module.exports, 'files', { get: function () { return files } }) node-minimatch-3.0.4/test/redos.js000066400000000000000000000012061310627514700170500ustar00rootroot00000000000000var t = require('tap') var minimatch = require('../') // utility function for generating long strings var genstr = function (len, chr) { var result = '' for (var i = 0; i <= len; i++) { result = result + chr } return result } var exploit = '!(' + genstr(1024 * 15, '\\') + 'A)' // within the limits, and valid match t.ok(minimatch('A', exploit)) // within the limits, but results in an invalid regexp exploit = '[!(' + genstr(1024 * 15, '\\') + 'A' t.notOk(minimatch('A', exploit)) t.throws(function () { // too long, throws TypeError exploit = '!(' + genstr(1024 * 64, '\\') + 'A)' minimatch('A', exploit) }, TypeError) node-minimatch-3.0.4/test/tricky-negations.js000066400000000000000000000044161310627514700212340ustar00rootroot00000000000000var t = require('tap') var minimatch = require('../') var cases = { 'bar.min.js': { '*.!(js|css)': true, '!*.+(js|css)': false, '*.+(js|css)': true }, 'a-integration-test.js': { '*.!(j)': true, '!(*-integration-test.js)': false, '*-!(integration-)test.js': true, '*-!(integration)-test.js': false, '*!(-integration)-test.js': true, '*!(-integration-)test.js': true, '*!(integration)-test.js': true, '*!(integration-test).js': true, '*-!(integration-test).js': true, '*-!(integration-test.js)': true, '*-!(integra)tion-test.js': false, '*-integr!(ation)-test.js': false, '*-integr!(ation-t)est.js': false, '*-i!(ntegration-)test.js': false, '*i!(ntegration-)test.js': true, '*te!(gration-te)st.js': true, '*-!(integration)?test.js': false, '*?!(integration)?test.js': true }, 'foo-integration-test.js': { 'foo-integration-test.js': true, '!(*-integration-test.js)': false }, 'foo.jszzz.js': { '*.!(js).js': true }, 'asd.jss': { '*.!(js)': true }, 'asd.jss.xyz': { '*.!(js).!(xy)': true }, 'asd.jss.xy': { '*.!(js).!(xy)': false }, 'asd.js.xyz': { '*.!(js).!(xy)': false }, 'asd.js.xy': { '*.!(js).!(xy)': false }, 'asd.sjs.zxy': { '*.!(js).!(xy)': true }, 'asd..xyz': { '*.!(js).!(xy)': true }, 'asd..xy': { '*.!(js).!(xy)': false, '*.!(js|x).!(xy)': false }, 'foo.js.js': { '*.!(js)': true }, 'testjson.json': { '*(*.json|!(*.js))': true, '+(*.json|!(*.js))': true, '@(*.json|!(*.js))': true, '?(*.json|!(*.js))': true }, 'foojs.js': { '*(*.json|!(*.js))': false, // XXX bash 4.3 disagrees! '+(*.json|!(*.js))': false, // XXX bash 4.3 disagrees! '@(*.json|!(*.js))': false, '?(*.json|!(*.js))': false }, 'other.bar': { '*(*.json|!(*.js))': true, '+(*.json|!(*.js))': true, '@(*.json|!(*.js))': true, '?(*.json|!(*.js))': true } } var options = { nonegate: true } Object.keys(cases).forEach(function (file) { t.test(file, function (t) { Object.keys(cases[file]).forEach(function (pattern) { var res = cases[file][pattern] var s = file + ' ' + pattern t.equal(minimatch(file, pattern, options), res, s) }) t.end() }) })