Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Browse files

pull minimatch leftwards

  • Loading branch information...
commit 50f321bcfa0e07d18a159a6b36c527a2e55c50c1 1 parent ed2a3c1
@isaacs isaacs authored
Showing with 44 additions and 3,076 deletions.
  1. +0 −159 lib/utils/excludes.js
  2. +0 −4 node_modules/fstream-npm/node_modules/fstream-ignore/node_modules/minimatch/.travis.yml
  3. +0 −23 node_modules/fstream-npm/node_modules/fstream-ignore/node_modules/minimatch/LICENSE
  4. +0 −218 node_modules/fstream-npm/node_modules/fstream-ignore/node_modules/minimatch/README.md
  5. +0 −986 node_modules/fstream-npm/node_modules/fstream-ignore/node_modules/minimatch/minimatch.js
  6. +0 −44 node_modules/fstream-npm/node_modules/fstream-ignore/node_modules/minimatch/package.json
  7. +0 −273 node_modules/fstream-npm/node_modules/fstream-ignore/node_modules/minimatch/test/basic.js
  8. +0 −33 node_modules/fstream-npm/node_modules/fstream-ignore/node_modules/minimatch/test/brace-expand.js
  9. +0 −14 node_modules/fstream-npm/node_modules/fstream-ignore/node_modules/minimatch/test/caching.js
  10. +10 −4 node_modules/minimatch/README.md
  11. +11 −35 node_modules/minimatch/minimatch.js
  12. +22 −7 node_modules/minimatch/package.json
  13. +0 −4 node_modules/node-gyp/node_modules/glob/node_modules/minimatch/.travis.yml
  14. +0 −23 node_modules/node-gyp/node_modules/glob/node_modules/minimatch/LICENSE
  15. +0 −218 node_modules/node-gyp/node_modules/glob/node_modules/minimatch/README.md
  16. +0 −986 node_modules/node-gyp/node_modules/glob/node_modules/minimatch/minimatch.js
  17. +0 −44 node_modules/node-gyp/node_modules/glob/node_modules/minimatch/package.json
  18. +1 −1  package.json
View
159 lib/utils/excludes.js
@@ -1,159 +0,0 @@
-// build up a set of exclude lists in order of precedence:
-// [ ["!foo", "bar"]
-// , ["foo", "!bar"] ]
-// being *included* will override a previous exclusion,
-// and being excluded will override a previous inclusion.
-//
-// Each time the tar file-list generator thingie enters a new directory,
-// it calls "addIgnoreFile(dir, list, cb)". If an ignore file is found,
-// then it is added to the list and the cb() is called with an
-// child of the original list, so that we don't have
-// to worry about popping it off at the right time, since other
-// directories will continue to use the original parent list.
-//
-// If no ignore file is found, then the original list is returned.
-//
-// To start off with, ~/.{npm,git}ignore is added, as is
-// prefix/{npm,git}ignore, effectively treated as if they were in the
-// base package directory.
-
-exports.addIgnoreFile = addIgnoreFile
-exports.readIgnoreFile = readIgnoreFile
-exports.parseIgnoreFile = parseIgnoreFile
-exports.test = test
-exports.filter = filter
-
-var path = require("path")
- , fs = require("graceful-fs")
- , minimatch = require("minimatch")
- , relativize = require("./relativize.js")
- , log = require("./log.js")
-
-// todo: memoize
-
-// read an ignore file, or fall back to the
-// "gitBase" file in the same directory.
-function readIgnoreFile (file, gitBase, cb) {
- //log.warn(file, "ignoreFile")
- if (!file) return cb(null, "")
- fs.readFile(file, function (er, data) {
- if (!er || !gitBase) return cb(null, data || "")
- var gitFile = path.resolve(path.dirname(file), gitBase)
- fs.readFile(gitFile, function (er, data) {
- return cb(null, data || "")
- })
- })
-}
-
-// read a file, and then return the list of patterns
-function parseIgnoreFile (file, gitBase, dir, cb) {
- readIgnoreFile(file, gitBase, function (er, data) {
- data = data ? data.toString("utf8") : ""
-
- data = data.split(/[\r\n]+/).map(function (p) {
- return p.trim()
- }).filter(function (p) {
- return p.length && p.charAt(0) !== "#"
- })
- data.dir = dir
- return cb(er, data)
- })
-}
-
-// add an ignore file to an existing list which can
-// then be passed to the test() function. If the ignore
-// file doesn't exist, then the list is unmodified. If
-// it is, then a concat-child of the original is returned,
-// so that this is suitable for walking a directory tree.
-function addIgnoreFile (file, gitBase, list, dir, cb) {
- if (typeof cb !== "function") cb = dir, dir = path.dirname(file)
- if (typeof cb !== "function") cb = list, list = []
- parseIgnoreFile(file, gitBase, dir, function (er, data) {
- if (!er && data) {
- // package.json "files" array trumps everything
- // Make sure it's always last.
- if (list.length && list[list.length-1].packageFiles) {
- list = list.concat([data, list.pop()])
- } else {
- list = list.concat([data])
- }
- }
- cb(er, list)
- })
-}
-
-
-// no IO
-// loop through the lists created in the functions above, and test to
-// see if a file should be included or not, given those exclude lists.
-function test (file, excludeList) {
- if (path.basename(file) === "package.json") return true
- // log.warn(file, "test file")
- // log.warn(excludeList, "test list")
- var incRe = /^\!(\!\!)*/
- , excluded = false
- , mmconf = { matchBase: true, dot: true }
- for (var i = 0, l = excludeList.length; i < l; i ++) {
- var excludes = excludeList[i]
- , dir = excludes.dir
-
- // chop the filename down to be relative to excludeDir
- var rf = relativize(file, dir, true)
- rf = rf.replace(/^\.?\//, "")
- if (file.slice(-1) === "/") rf += "/"
-
- // log.warn([file, rf], "rf")
-
- for (var ii = 0, ll = excludes.length; ii < ll; ii ++) {
- var ex = excludes[ii].replace(/^(!*)\//, "$1")
- , inc = !!ex.match(incRe)
-
- // log.warn([ex, rf], "ex, rf")
- // excluding/including a dir excludes/includes all the files in it.
- if (ex.slice(-1) === "/") ex += "**"
-
- // if this is not an inclusion attempt, and someone else
- // excluded it, then just continue, because there's nothing
- // that can be done here to change the exclusion.
- if (!inc && excluded) continue
-
- // if it's an inclusion attempt, and the file has not been
- // excluded, then skip it, because there's no need to try again.
- if (inc && !excluded) continue
-
- // if it matches the pattern, then it should be excluded.
- excluded = !!minimatch(rf, ex, mmconf)
- // log.error([rf, ex, excluded], "rf, ex, excluded")
-
- // if you include foo, then it also includes foo/bar.js
- if (inc && excluded && ex.slice(-3) !== "/**") {
- excluded = minimatch(rf, ex + "/**", mmconf)
- // log.warn([rf, ex + "/**", inc, excluded], "dir without /")
- }
-
- // if you exclude foo, then it also excludes foo/bar.js
- if (!inc
- && excluded
- && ex.slice(-3) !== "/**"
- && rf.slice(-1) === "/"
- && excludes.indexOf(ex + "/**") === -1) {
- // log.warn(ex + "/**", "adding dir-matching exclude pattern")
- excludes.splice(ii, 1, ex, ex + "/**")
- ll ++
- }
- }
-
- // log.warn([rf, excluded, excludes], "rf, excluded, excludes")
- }
- // true if it *should* be included
- // log.warn([file, excludeList, excluded], "file, excluded")
- return !excluded
-}
-
-// returns a function suitable for Array#filter
-function filter (dir, list) { return function (file) {
- file = file.trim()
- var testFile = path.resolve(dir, file)
- if (file.slice(-1) === "/") testFile += "/"
- return file && test(testFile, list)
-}}
View
4 node_modules/fstream-npm/node_modules/fstream-ignore/node_modules/minimatch/.travis.yml
@@ -1,4 +0,0 @@
-language: node_js
-node_js:
- - 0.4
- - 0.6
View
23 node_modules/fstream-npm/node_modules/fstream-ignore/node_modules/minimatch/LICENSE
@@ -1,23 +0,0 @@
-Copyright 2009, 2010, 2011 Isaac Z. Schlueter.
-All rights reserved.
-
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation
-files (the "Software"), to deal in the Software without
-restriction, including without limitation the rights to use,
-copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the
-Software is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.
View
218 node_modules/fstream-npm/node_modules/fstream-ignore/node_modules/minimatch/README.md
@@ -1,218 +0,0 @@
-# minimatch
-
-A minimal matching utility.
-
-[![Build Status](https://secure.travis-ci.org/isaacs/minimatch.png)](http://travis-ci.org/isaacs/minimatch)
-
-
-This is the matching library used internally by npm.
-
-Eventually, it will replace the C binding in node-glob.
-
-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!
-```
-
-## Features
-
-Supports these glob features:
-
-* Brace Expansion
-* Extended glob matching
-* "Globstar" `**` matching
-
-See:
-
-* `man sh`
-* `man bash`
-* `man 3 fnmatch`
-* `man 5 gitignore`
-
-### 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. **Note that this is different from the way that `**` is
-handled by ruby's `Dir` class.**
-
-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.
-
-
-## Minimatch Class
-
-Create a minimatch object by instanting 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.
-
-## Functions
-
-The top-level exported function has a `cache` property, which is an LRU
-cache set to store 100 items. So, calling these methods repeatedly
-with the same pattern and options will use the same Minimatch object,
-saving the cost of parsing it multiple times.
-
-### 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. When 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.)
View
986 node_modules/fstream-npm/node_modules/fstream-ignore/node_modules/minimatch/minimatch.js
@@ -1,986 +0,0 @@
-module.exports = minimatch
-minimatch.Minimatch = Minimatch
-
-var LRU = require("lru-cache")
- , cache = minimatch.cache = new LRU(100)
- , GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {}
-
-var path = require("path")
- // any single thing other than /
- // don't need to escape / when using new RegExp()
- , qmark = "[^/]"
-
- // * => any number of characters
- , 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.
- , twoStarDot = "(?:(?!(?:\\\/|^)(?:\\.{1,2})($|\\\/)).)*?"
-
- // not a ^ or / followed by a dot,
- // followed by anything, any number of times.
- , twoStarNoDot = "(?:(?!(?:\\\/|^)\\.).)*?"
-
- // characters that need to be escaped in RegExp.
- , 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.monkeyPatch = monkeyPatch
-function monkeyPatch () {
- var desc = Object.getOwnPropertyDescriptor(String.prototype, "match")
- var orig = desc.value
- desc.value = function (p) {
- if (p instanceof Minimatch) return p.match(this)
- return orig.call(this, p)
- }
- Object.defineProperty(String.prototype, desc)
-}
-
-minimatch.filter = filter
-function filter (pattern, options) {
- options = options || {}
- return function (p, i, list) {
- return minimatch(p, pattern, options)
- }
-}
-
-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, cache)
- }
-
- if (typeof pattern !== "string") {
- throw new TypeError("glob pattern string required")
- }
-
- if (!options) options = {}
- pattern = pattern.trim()
-
- // lru storage.
- // these things aren't particularly big, but walking down the string
- // and turning it into a regexp can get pretty costly.
- var cacheKey = pattern + "\n" + Object.keys(options).filter(function (k) {
- return options[k]
- }).join(":")
- var cached = minimatch.cache.get(cacheKey)
- if (cached) return cached
- minimatch.cache.set(cacheKey, this)
-
- 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.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) console.error(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)
- })
-
- if (options.debug) console.error(this.pattern, set)
-
- // glob --> regexps
- set = set.map(function (s, si, set) {
- return s.map(this.parse, this)
- }, this)
-
- if (options.debug) console.error(this.pattern, set)
-
- // filter out everything that didn't compile properly.
- set = set.filter(function (s) {
- return -1 === s.indexOf(false)
- })
-
- if (options.debug) console.error(this.pattern, set)
-
- this.set = set
-}
-
-Minimatch.prototype.parseNegate = parseNegate
-function parseNegate () {
- var pattern = this.pattern
- , negate = false
- , options = this.options
- , 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 new Minimatch(pattern, options).braceExpand()
-}
-
-Minimatch.prototype.braceExpand = braceExpand
-function braceExpand (pattern, options) {
- options = options || this.options
- pattern = typeof pattern === "undefined"
- ? this.pattern : pattern
-
- if (typeof pattern === "undefined") {
- throw new Error("undefined pattern")
- }
-
- if (options.nobrace ||
- !pattern.match(/\{.*\}/)) {
- // shortcut. no need to expand.
- return [pattern]
- }
-
- var escaping = false
-
- // examples and comments refer to this crazy pattern:
- // a{b,c{d,e},{f,g}h}x{y,z}
- // expected:
- // abxy
- // abxz
- // acdxy
- // acdxz
- // acexy
- // acexz
- // afhxy
- // afhxz
- // aghxy
- // aghxz
-
- // everything before the first \{ is just a prefix.
- // So, we pluck that off, and work with the rest,
- // and then prepend it to everything we find.
- if (pattern.charAt(0) !== "{") {
- // console.error(pattern)
- var prefix = null
- for (var i = 0, l = pattern.length; i < l; i ++) {
- var c = pattern.charAt(i)
- // console.error(i, c)
- if (c === "\\") {
- escaping = !escaping
- } else if (c === "{" && !escaping) {
- prefix = pattern.substr(0, i)
- break
- }
- }
-
- // actually no sets, all { were escaped.
- if (prefix === null) {
- // console.error("no sets")
- return [pattern]
- }
-
- var tail = braceExpand(pattern.substr(i), options)
- return tail.map(function (t) {
- return prefix + t
- })
- }
-
- // now we have something like:
- // {b,c{d,e},{f,g}h}x{y,z}
- // walk through the set, expanding each part, until
- // the set ends. then, we'll expand the suffix.
- // If the set only has a single member, then'll put the {} back
-
- // first, handle numeric sets, since they're easier
- var numset = pattern.match(/^\{(-?[0-9]+)\.\.(-?[0-9]+)\}/)
- if (numset) {
- // console.error("numset", numset[1], numset[2])
- var suf = braceExpand(pattern.substr(numset[0].length), options)
- , start = +numset[1]
- , end = +numset[2]
- , inc = start > end ? -1 : 1
- , set = []
- for (var i = start; i != (end + inc); i += inc) {
- // append all the suffixes
- for (var ii = 0, ll = suf.length; ii < ll; ii ++) {
- set.push(i + suf[ii])
- }
- }
- return set
- }
-
- // ok, walk through the set
- // We hope, somewhat optimistically, that there
- // will be a } at the end.
- // If the closing brace isn't found, then the pattern is
- // interpreted as braceExpand("\\" + pattern) so that
- // the leading \{ will be interpreted literally.
- var i = 1 // skip the \{
- , depth = 1
- , set = []
- , member = ""
- , sawEnd = false
- , escaping = false
-
- function addMember () {
- set.push(member)
- member = ""
- }
-
- // console.error("Entering for")
- FOR: for (i = 1, l = pattern.length; i < l; i ++) {
- var c = pattern.charAt(i)
- // console.error("", i, c)
-
- if (escaping) {
- escaping = false
- member += "\\" + c
- } else {
- switch (c) {
- case "\\":
- escaping = true
- continue
-
- case "{":
- depth ++
- member += "{"
- continue
-
- case "}":
- depth --
- // if this closes the actual set, then we're done
- if (depth === 0) {
- addMember()
- // pluck off the close-brace
- i ++
- break FOR
- } else {
- member += c
- continue
- }
-
- case ",":
- if (depth === 1) {
- addMember()
- } else {
- member += c
- }
- continue
-
- default:
- member += c
- continue
- } // switch
- } // else
- } // for
-
- // now we've either finished the set, and the suffix is
- // pattern.substr(i), or we have *not* closed the set,
- // and need to escape the leading brace
- if (depth !== 0) {
- // console.error("didn't close", pattern)
- return braceExpand("\\" + pattern, options)
- }
-
- // x{y,z} -> ["xy", "xz"]
- // console.error("set", set)
- // console.error("suffix", pattern.substr(i))
- var suf = braceExpand(pattern.substr(i), options)
- // ["b", "c{d,e}","{f,g}h"] ->
- // [["b"], ["cd", "ce"], ["fh", "gh"]]
- var addBraces = set.length === 1
- // console.error("set pre-expanded", set)
- set = set.map(function (p) {
- return braceExpand(p, options)
- })
- // console.error("set expanded", set)
-
-
- // [["b"], ["cd", "ce"], ["fh", "gh"]] ->
- // ["b", "cd", "ce", "fh", "gh"]
- set = set.reduce(function (l, r) {
- return l.concat(r)
- })
-
- if (addBraces) {
- set = set.map(function (s) {
- return "{" + s + "}"
- })
- }
-
- // now attach the suffixes.
- var ret = []
- for (var i = 0, l = set.length; i < l; i ++) {
- for (var ii = 0, ll = suf.length; ii < ll; ii ++) {
- ret.push(set[i] + suf[ii])
- }
- }
- return ret
-}
-
-// 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) {
- var options = this.options
-
- // shortcuts
- if (!options.noglobstar && pattern === "**") return GLOBSTAR
- if (pattern === "") return ""
-
- var re = ""
- , hasMagic = false
- , escaping = false
- // ? => one single character
- , patternListStack = []
- , plType
- , stateChar
- , inClass = false
- , reClassStart = -1
- , classStart = -1
- // . and .. never match anything that doesn't start with .,
- // even when options.dot is set.
- , patternStart = pattern.charAt(0) === "." ? "" // anything
- // not (start or / followed by . or .. followed by / or end)
- : options.dot ? "(?!(?:^|\\\/)\\.{1,2}(?:$|\\\/))"
- : "(?!\\.)"
-
- 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
- }
- stateChar = false
- }
- }
-
- for ( var i = 0, len = pattern.length, c
- ; (i < len) && (c = pattern.charAt(i))
- ; i ++ ) {
-
- if (options.debug) {
- console.error("%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: 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 "!":
- if (options.debug) {
- console.error("%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) {
- 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.
- 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
- }
-
- plType = stateChar
- patternListStack.push({ type: plType
- , start: i - 1
- , reStart: re.length })
- // negation is (?:(?!js)[^/]*)
- re += stateChar === "!" ? "(?:(?!" : "(?:"
- stateChar = false
- continue
-
- case ")":
- if (inClass || !patternListStack.length) {
- re += "\\)"
- continue
- }
-
- hasMagic = true
- re += ")"
- plType = patternListStack.pop().type
- // negation is (?:(?!js)[^/]*)
- // The others are (?:<pattern>)<type>
- switch (plType) {
- case "!":
- re += "[^/]*?)"
- break
- case "?":
- case "+":
- case "*": re += plType
- case "@": break // the default anyway
- }
- continue
-
- case "|":
- if (inClass || !patternListStack.length || escaping) {
- re += "\\|"
- escaping = false
- continue
- }
-
- 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
- }
-
- // 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
- var 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.
- var pl
- while (pl = patternListStack.pop()) {
- var tail = re.slice(pl.reStart + 3)
- // maybe some even number of \, then maybe 1 \, followed by a |
- tail = tail.replace(/((?:\\{2})*)(\\?)\|/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 + "|"
- })
-
- // console.error("tail=%j\n %s", tail, tail)
- 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
- }
-
- // 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" : ""
- , regExp = new RegExp("^" + re + "$", flags)
-
- 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) return this.regexp = false
- var options = this.options
-
- var twoStar = options.noglobstar ? star
- : options.dot ? twoStarDot
- : twoStarNoDot
- , 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 {
- return this.regexp = new RegExp(re, flags)
- } catch (ex) {
- return this.regexp = false
- }
-}
-
-minimatch.match = function (list, pattern, options) {
- var mm = new Minimatch(pattern, options)
- list = list.filter(function (f) {
- return mm.match(f)
- })
- if (options.nonull && !list.length) {
- list.push(pattern)
- }
- return list
-}
-
-Minimatch.prototype.match = match
-function match (f, partial) {
- // console.error("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
-
- // first, normalize any slash-separated path parts.
- // f = path.normalize(f)
-
- // windows: need to use /, not \
- // On other platforms, \ is a valid (albeit bad) filename char.
- if (process.platform === "win32") {
- f = f.split("\\").join("/")
- }
-
- // treat the test path as a set of pathparts.
- f = f.split(slashSplit)
- if (options.debug) {
- console.error(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
- // console.error(this.pattern, "set", set)
-
- for (var i = 0, l = set.length; i < l; i ++) {
- var pattern = set[i]
- var hit = this.matchOne(f, 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
-
- if (options.debug) {
- console.error("matchOne",
- { "this": this
- , file: file
- , pattern: pattern })
- }
-
- if (options.matchBase && pattern.length === 1) {
- file = path.basename(file.join("/")).split("/")
- }
-
- if (options.debug) {
- console.error("matchOne", file.length, pattern.length)
- }
-
- for ( var fi = 0
- , pi = 0
- , fl = file.length
- , pl = pattern.length
- ; (fi < fl) && (pi < pl)
- ; fi ++, pi ++ ) {
-
- if (options.debug) {
- console.error("matchOne loop")
- }
- var p = pattern[pi]
- , f = file[fi]
-
- if (options.debug) {
- console.error(pattern, p, f)
- }
-
- // should be impossible.
- // some invalid regexp stuff in the set.
- if (p === false) return false
-
- if (p === GLOBSTAR) {
- // "**"
- // 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/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
- , pr = pi + 1
- if (pr === pl) {
- // 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: while (fr < fl) {
- var swallowee = file[fr]
- if (swallowee === "." || swallowee === ".." ||
- (!options.dot && swallowee.charAt(0) === ".")) {
- // console.error("dot detected!")
- break WHILE
- }
-
- // XXX remove this slice. Just pass the start index.
- if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
- // found a match.
- return true
- } else {
- // ** swallows 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
- // console.error("\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
- }
- if (options.debug) {
- console.error("string match", p, f, hit)
- }
- } else {
- hit = f.match(p)
- if (options.debug) {
- console.error("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, "\\$&")
-}
View
44 node_modules/fstream-npm/node_modules/fstream-ignore/node_modules/minimatch/package.json
@@ -1,44 +0,0 @@
-{
- "author": {
- "name": "Isaac Z. Schlueter",
- "email": "i@izs.me",
- "url": "http://blog.izs.me"
- },
- "name": "minimatch",
- "description": "a glob matcher in javascript",
- "version": "0.2.2",
- "repository": {
- "type": "git",
- "url": "git://github.com/isaacs/minimatch.git"
- },
- "main": "minimatch.js",
- "scripts": {
- "test": "tap test"
- },
- "engines": {
- "node": "*"
- },
- "dependencies": {
- "lru-cache": "~1.0.5"
- },
- "devDependencies": {
- "tap": ""
- },
- "licenses": [
- {
- "type": "MIT",
- "url": "http://github.com/isaacs/minimatch/raw/master/LICENSE"
- }
- ],
- "_npmUser": {
- "name": "isaacs",
- "email": "i@izs.me"
- },
- "_id": "minimatch@0.2.2",
- "optionalDependencies": {},
- "_engineSupported": true,
- "_npmVersion": "1.1.12",
- "_nodeVersion": "v0.7.7-pre",
- "_defaultsLoaded": true,
- "_from": "minimatch@~0.2.0"
-}
View
273 node_modules/fstream-npm/node_modules/fstream-ignore/node_modules/minimatch/test/basic.js
@@ -1,273 +0,0 @@
-// 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")
- , globalBefore = Object.keys(global)
- , mm = require("../")
- , files = [ "a", "b", "c", "d", "abc"
- , "abd", "abe", "bb", "bcd"
- , "ca", "cb", "dd", "de"
- , "bdir/", "bdir/cfile"]
- , next = files.concat([ "a-b", "aXb"
- , ".x", ".y" ])
-
-tap.test("basic tests", function (t) {
- var start = Date.now()
-
- // [ pattern, [matches], MM opts, files, TAP opts]
- ; [ "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/^[^:]*:[^:]*:\([^:]*\).*$/\1/"
- , ["/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*$/\1/"], {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"
- // can't match this one without negative lookbehind.
- , "foo.js.js"
- , "blar.js"
- , "foo."
- , "boo.js.boo" ]
- }
- , ["*.!(js)", ["foo.bar", "foo.", "boo.js.boo"] ]
-
- ].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] || files
- , tapOpts = c[4] || {}
-
- // options.debug = true
- var m = new mm.Minimatch(pattern, options)
- 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)
- t.equivalent(globalAfter, globalBefore, "no new globals, please")
- t.end()
-})
-
-function alpha (a, b) {
- return a > b ? 1 : -1
-}
View
33 ...dules/fstream-npm/node_modules/fstream-ignore/node_modules/minimatch/test/brace-expand.js
@@ -1,33 +0,0 @@
-var tap = require("tap")
- , minimatch = require("../")
-
-tap.test("brace expansion", function (t) {
- // [ pattern, [expanded] ]
- ; [ [ "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"] ]
- ].forEach(function (tc) {
- var p = tc[0]
- , expect = tc[1]
- t.equivalent(minimatch.braceExpand(p), expect, p)
- })
- console.error("ending")
- t.end()
-})
-
-
View
14 node_modules/fstream-npm/node_modules/fstream-ignore/node_modules/minimatch/test/caching.js
@@ -1,14 +0,0 @@
-var Minimatch = require("../minimatch.js").Minimatch
-var tap = require("tap")
-tap.test("cache test", function (t) {
- var mm1 = new Minimatch("a?b")
- var mm2 = new Minimatch("a?b")
- t.equal(mm1, mm2, "should get the same object")
- // the lru should drop it after 100 entries
- for (var i = 0; i < 100; i ++) {
- new Minimatch("a"+i)
- }
- mm2 = new Minimatch("a?b")
- t.notEqual(mm1, mm2, "cache should have dropped")
- t.end()
-})
View
14 node_modules/minimatch/README.md
@@ -60,11 +60,12 @@ thing in a path part. That is, `a/**/b` will match `a/x/y/b`, but
`a/**b` will not. **Note that this is different from the way that `**` is
handled by ruby's `Dir` class.**
-If an escaped pattern has no matches, and the `null` flag is not set,
+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?"`.
+`"*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
@@ -147,8 +148,8 @@ 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, then
-return the pattern (unless `{ null: true }` in the options.)
+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}))
@@ -210,3 +211,8 @@ 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.)
View
46 node_modules/minimatch/minimatch.js
@@ -4,7 +4,6 @@ minimatch.Minimatch = Minimatch
var LRU = require("lru-cache")
, cache = minimatch.cache = new LRU(100)
, GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {}
- , pathSplit = process.platform === "win32" ? /\\|\// : "/"
var path = require("path")
// any single thing other than /
@@ -130,7 +129,7 @@ function make () {
this.parseNegate()
// step 2: expand braces
- var set = this.braceExpand()
+ var set = this.globSet = this.braceExpand()
if (options.debug) console.error(this.pattern, set)
@@ -139,7 +138,7 @@ function make () {
// 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 = set.map(function (s) {
+ set = this.globParts = set.map(function (s) {
return s.split(slashSplit)
})
@@ -159,36 +158,6 @@ function make () {
if (options.debug) console.error(this.pattern, set)
- // step 4: if we have a defined root, then patterns starting with ""
- // get attached to that. If we have a defined cwd, then patterns
- // *not* starting with "" get attached to that.
- // Exception 1: on windows, a pattern like //\?/c:/ or c:/ will
- // not get anything prefixed to it.
- // Exception 2: If matchBase is set, and it's just a filename,
- // then don't prefix anything onto it, since it'll only match
- // files with that basename anyhow.
- set = set.map(function (p) {
- if (process.platform === "win32" &&
- ( (p[0] === "" && p[1] === "" && p[2] === "\\?") // unc
- || (typeof p[0] === "string" && p[0].match(/^[a-zA-Z]:$/)) )) {
- return p
- }
- if (options.matchBase && p.length === 1) return p
- // do prefixing.
- if (options.root && p[0] === "") {
- var r = options.root.split(pathSplit)
- if (r[r.length - 1] === "") r.pop()
- r = r.concat(p.slice(1))
- r.absolute = true
- return r
- }
- if (options.cwd && p[0] !== "") {
- return options.cwd.split(pathSplit).concat(p)
- }
- return p
- })
-
-
this.set = set
}
@@ -549,7 +518,8 @@ function parse (pattern, isSub) {
patternListStack.push({ type: plType
, start: i - 1
, reStart: re.length })
- re += stateChar === "!" ? "(?!" : "(?:"
+ // negation is (?:(?!js)[^/]*)
+ re += stateChar === "!" ? "(?:(?!" : "(?:"
stateChar = false
continue
@@ -562,11 +532,15 @@ function parse (pattern, isSub) {
hasMagic = true
re += ")"
plType = patternListStack.pop().type
+ // negation is (?:(?!js)[^/]*)
+ // The others are (?:<pattern>)<type>
switch (plType) {
+ case "!":
+ re += "[^/]*?)"
+ break
case "?":
case "+":
case "*": re += plType
- case "!": // already handled by the start
case "@": break // the default anyway
}
continue
@@ -821,12 +795,14 @@ function match (f, partial) {
var pattern = set[i]
var hit = this.matchOne(f, 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
}
View
29 node_modules/minimatch/package.json
@@ -1,8 +1,12 @@
{
- "author": "Isaac Z. Schlueter <i@izs.me> (http://blog.izs.me)",
+ "author": {
+ "name": "Isaac Z. Schlueter",
+ "email": "i@izs.me",
+ "url": "http://blog.izs.me"
+ },
"name": "minimatch",
"description": "a glob matcher in javascript",
- "version": "0.1.5",
+ "version": "0.2.2",
"repository": {
"type": "git",
"url": "git://github.com/isaacs/minimatch.git"
@@ -18,12 +22,23 @@
"lru-cache": "~1.0.5"
},
"devDependencies": {
- "tap": "~0.1.3"
+ "tap": ""
},
- "licenses" : [
+ "licenses": [
{
- "type" : "MIT",
- "url" : "http://github.com/isaacs/minimatch/raw/master/LICENSE"
+ "type": "MIT",
+ "url": "http://github.com/isaacs/minimatch/raw/master/LICENSE"
}
- ]
+ ],
+ "_npmUser": {
+ "name": "isaacs",
+ "email": "i@izs.me"
+ },
+ "_id": "minimatch@0.2.2",
+ "optionalDependencies": {},
+ "_engineSupported": true,
+ "_npmVersion": "1.1.12",
+ "_nodeVersion": "v0.7.7-pre",
+ "_defaultsLoaded": true,
+ "_from": "minimatch@0"
}
View
4 node_modules/node-gyp/node_modules/glob/node_modules/minimatch/.travis.yml
@@ -1,4 +0,0 @@
-language: node_js
-node_js:
- - 0.4
- - 0.6
View
23 node_modules/node-gyp/node_modules/glob/node_modules/minimatch/LICENSE
@@ -1,23 +0,0 @@
-Copyright 2009, 2010, 2011 Isaac Z. Schlueter.
-All rights reserved.
-
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation
-files (the "Software"), to deal in the Software without
-restriction, including without limitation the rights to use,
-copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the
-Software is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.
View
218 node_modules/node-gyp/node_modules/glob/node_modules/minimatch/README.md
@@ -1,218 +0,0 @@
-# minimatch
-
-A minimal matching utility.
-
-[![Build Status](https://secure.travis-ci.org/isaacs/minimatch.png)](http://travis-ci.org/isaacs/minimatch)
-
-
-This is the matching library used internally by npm.
-
-Eventually, it will replace the C binding in node-glob.
-
-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!
-```
-
-## Features
-
-Supports these glob features:
-
-* Brace Expansion
-* Extended glob matching
-* "Globstar" `**` matching
-
-See:
-
-* `man sh`
-* `man bash`
-* `man 3 fnmatch`
-* `man 5 gitignore`
-
-### 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. **Note that this is different from the way that `**` is
-handled by ruby's `Dir` class.**
-
-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.
-
-
-## Minimatch Class
-
-Create a minimatch object by instanting 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.
-
-## Functions
-
-The top-level exported function has a `cache` property, which is an LRU
-cache set to store 100 items. So, calling these methods repeatedly
-with the same pattern and options will use the same Minimatch object,
-saving the cost of parsing it multiple times.
-
-### 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. When 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.)
View
986 node_modules/node-gyp/node_modules/glob/node_modules/minimatch/minimatch.js
@@ -1,986 +0,0 @@
-module.exports = minimatch
-minimatch.Minimatch = Minimatch
-
-var LRU = require("lru-cache")
- , cache = minimatch.cache = new LRU(100)
- , GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {}
-
-var path = require("path")
- // any single thing other than /
- // don't need to escape / when using new RegExp()
- , qmark = "[^/]"
-
- // * => any number of characters
- , 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.
- , twoStarDot = "(?:(?!(?:\\\/|^)(?:\\.{1,2})($|\\\/)).)*?"
-
- // not a ^ or / followed by a dot,
- // followed by anything, any number of times.
- , twoStarNoDot = "(?:(?!(?:\\\/|^)\\.).)*?"
-
- // characters that need to be escaped in RegExp.
- , 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.monkeyPatch = monkeyPatch
-function monkeyPatch () {
- var desc = Object.getOwnPropertyDescriptor(String.prototype, "match")
- var orig = desc.value
- desc.value = function (p) {
- if (p instanceof Minimatch) return p.match(this)
- return orig.call(this, p)
- }
- Object.defineProperty(String.prototype, desc)
-}
-
-minimatch.filter = filter
-function filter (pattern, options) {
- options = options || {}
- return function (p, i, list) {
- return minimatch(p, pattern, options)
- }
-}
-
-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