You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cordova.apache.org by bh...@apache.org on 2014/03/27 16:08:22 UTC
[08/51] [partial] CB-6346 - Add node_modules to source control
http://git-wip-us.apache.org/repos/asf/cordova-blackberry/blob/1139813c/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/README.md
----------------------------------------------------------------------
diff --git a/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/README.md b/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/README.md
new file mode 100644
index 0000000..6fd07d2
--- /dev/null
+++ b/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/README.md
@@ -0,0 +1,218 @@
+# minimatch
+
+A minimal matching utility.
+
+[](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.)
http://git-wip-us.apache.org/repos/asf/cordova-blackberry/blob/1139813c/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/minimatch.js
----------------------------------------------------------------------
diff --git a/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/minimatch.js b/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/minimatch.js
new file mode 100644
index 0000000..405746b
--- /dev/null
+++ b/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/minimatch.js
@@ -0,0 +1,1079 @@
+;(function (require, exports, module, platform) {
+
+if (module) module.exports = minimatch
+else exports.minimatch = minimatch
+
+if (!require) {
+ require = function (id) {
+ switch (id) {
+ case "sigmund": return function sigmund (obj) {
+ return JSON.stringify(obj)
+ }
+ case "path": return { basename: function (f) {
+ f = f.split(/[\/\\]/)
+ var e = f.pop()
+ if (!e) e = f.pop()
+ return e
+ }}
+ case "lru-cache": return function LRUCache () {
+ // not quite an LRU, but still space-limited.
+ var cache = {}
+ var cnt = 0
+ this.set = function (k, v) {
+ cnt ++
+ if (cnt >= 100) cache = {}
+ cache[k] = v
+ }
+ this.get = function (k) { return cache[k] }
+ }
+ }
+ }
+}
+
+minimatch.Minimatch = Minimatch
+
+var LRU = require("lru-cache")
+ , cache = minimatch.cache = new LRU({max: 100})
+ , GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {}
+ , sigmund = require("sigmund")
+
+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 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, cache)
+ }
+
+ if (typeof pattern !== "string") {
+ throw new TypeError("glob pattern string required")
+ }
+
+ if (!options) options = {}
+ pattern = pattern.trim()
+
+ // windows: need to use /, not \
+ // On other platforms, \ is a valid (albeit bad) filename char.
+ if (platform === "win32") {
+ pattern = pattern.split("\\").join("/")
+ }
+
+ // 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" + sigmund(options)
+ 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 = !!options.nocase
+ , 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
+
+ // windows: need to use /, not \
+ // On other platforms, \ is a valid (albeit bad) filename char.
+ if (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) {
+ if (options.debug)
+ console.error('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
+ , pr = pi + 1
+ if (pr === pl) {
+ if (options.debug)
+ console.error('** 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: while (fr < fl) {
+ var swallowee = file[fr]
+
+ if (options.debug) {
+ console.error('\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)) {
+ if (options.debug)
+ console.error('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) === ".")) {
+ if (options.debug)
+ console.error("dot detected!", file, fr, pattern, pr)
+ break WHILE
+ }
+
+ // ** swallows a segment, and continue.
+ if (options.debug)
+ console.error('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
+ // 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, "\\$&")
+}
+
+})( typeof require === "function" ? require : null,
+ this,
+ typeof module === "object" ? module : null,
+ typeof process === "object" ? process.platform : "win32"
+ )
http://git-wip-us.apache.org/repos/asf/cordova-blackberry/blob/1139813c/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/.npmignore
----------------------------------------------------------------------
diff --git a/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/.npmignore b/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/.npmignore
new file mode 100644
index 0000000..07e6e47
--- /dev/null
+++ b/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/.npmignore
@@ -0,0 +1 @@
+/node_modules
http://git-wip-us.apache.org/repos/asf/cordova-blackberry/blob/1139813c/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/AUTHORS
----------------------------------------------------------------------
diff --git a/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/AUTHORS b/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/AUTHORS
new file mode 100644
index 0000000..016d7fb
--- /dev/null
+++ b/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/AUTHORS
@@ -0,0 +1,8 @@
+# Authors, sorted by whether or not they are me
+Isaac Z. Schlueter <i...@izs.me>
+Carlos Brito Lage <ca...@carloslage.net>
+Marko Mikulicic <ma...@isti.cnr.it>
+Trent Mick <tr...@gmail.com>
+Kevin O'Hara <ke...@gmail.com>
+Marco Rogers <ma...@gmail.com>
+Jesse Dailey <je...@gmail.com>
http://git-wip-us.apache.org/repos/asf/cordova-blackberry/blob/1139813c/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/LICENSE
----------------------------------------------------------------------
diff --git a/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/LICENSE b/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/LICENSE
new file mode 100644
index 0000000..05a4010
--- /dev/null
+++ b/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/LICENSE
@@ -0,0 +1,23 @@
+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.
http://git-wip-us.apache.org/repos/asf/cordova-blackberry/blob/1139813c/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/README.md
----------------------------------------------------------------------
diff --git a/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/README.md b/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/README.md
new file mode 100644
index 0000000..03ee0f9
--- /dev/null
+++ b/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/README.md
@@ -0,0 +1,97 @@
+# lru cache
+
+A cache object that deletes the least-recently-used items.
+
+## Usage:
+
+```javascript
+var LRU = require("lru-cache")
+ , options = { max: 500
+ , length: function (n) { return n * 2 }
+ , dispose: function (key, n) { n.close() }
+ , maxAge: 1000 * 60 * 60 }
+ , cache = LRU(options)
+ , otherCache = LRU(50) // sets just the max size
+
+cache.set("key", "value")
+cache.get("key") // "value"
+
+cache.reset() // empty the cache
+```
+
+If you put more stuff in it, then items will fall out.
+
+If you try to put an oversized thing in it, then it'll fall out right
+away.
+
+## Options
+
+* `max` The maximum size of the cache, checked by applying the length
+ function to all values in the cache. Not setting this is kind of
+ silly, since that's the whole purpose of this lib, but it defaults
+ to `Infinity`.
+* `maxAge` Maximum age in ms. Items are not pro-actively pruned out
+ as they age, but if you try to get an item that is too old, it'll
+ drop it and return undefined instead of giving it to you.
+* `length` Function that is used to calculate the length of stored
+ items. If you're storing strings or buffers, then you probably want
+ to do something like `function(n){return n.length}`. The default is
+ `function(n){return 1}`, which is fine if you want to store `n`
+ like-sized things.
+* `dispose` Function that is called on items when they are dropped
+ from the cache. This can be handy if you want to close file
+ descriptors or do other cleanup tasks when items are no longer
+ accessible. Called with `key, value`. It's called *before*
+ actually removing the item from the internal cache, so if you want
+ to immediately put it back in, you'll have to do that in a
+ `nextTick` or `setTimeout` callback or it won't do anything.
+* `stale` By default, if you set a `maxAge`, it'll only actually pull
+ stale items out of the cache when you `get(key)`. (That is, it's
+ not pre-emptively doing a `setTimeout` or anything.) If you set
+ `stale:true`, it'll return the stale value before deleting it. If
+ you don't set this, then it'll return `undefined` when you try to
+ get a stale entry, as if it had already been deleted.
+
+## API
+
+* `set(key, value)`
+* `get(key) => value`
+
+ Both of these will update the "recently used"-ness of the key.
+ They do what you think.
+
+* `peek(key)`
+
+ Returns the key value (or `undefined` if not found) without
+ updating the "recently used"-ness of the key.
+
+ (If you find yourself using this a lot, you *might* be using the
+ wrong sort of data structure, but there are some use cases where
+ it's handy.)
+
+* `del(key)`
+
+ Deletes a key out of the cache.
+
+* `reset()`
+
+ Clear the cache entirely, throwing away all values.
+
+* `has(key)`
+
+ Check if a key is in the cache, without updating the recent-ness
+ or deleting it for being stale.
+
+* `forEach(function(value,key,cache), [thisp])`
+
+ Just like `Array.prototype.forEach`. Iterates over all the keys
+ in the cache, in order of recent-ness. (Ie, more recently used
+ items are iterated over first.)
+
+* `keys()`
+
+ Return an array of the keys in the cache.
+
+* `values()`
+
+ Return an array of the values in the cache.
http://git-wip-us.apache.org/repos/asf/cordova-blackberry/blob/1139813c/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/lib/lru-cache.js
----------------------------------------------------------------------
diff --git a/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/lib/lru-cache.js b/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/lib/lru-cache.js
new file mode 100644
index 0000000..8c80853
--- /dev/null
+++ b/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/lib/lru-cache.js
@@ -0,0 +1,257 @@
+;(function () { // closure for web browsers
+
+if (typeof module === 'object' && module.exports) {
+ module.exports = LRUCache
+} else {
+ // just set the global for non-node platforms.
+ this.LRUCache = LRUCache
+}
+
+function hOP (obj, key) {
+ return Object.prototype.hasOwnProperty.call(obj, key)
+}
+
+function naiveLength () { return 1 }
+
+function LRUCache (options) {
+ if (!(this instanceof LRUCache)) {
+ return new LRUCache(options)
+ }
+
+ var max
+ if (typeof options === 'number') {
+ max = options
+ options = { max: max }
+ }
+
+ if (!options) options = {}
+
+ max = options.max
+
+ var lengthCalculator = options.length || naiveLength
+
+ if (typeof lengthCalculator !== "function") {
+ lengthCalculator = naiveLength
+ }
+
+ if (!max || !(typeof max === "number") || max <= 0 ) {
+ // a little bit silly. maybe this should throw?
+ max = Infinity
+ }
+
+ var allowStale = options.stale || false
+
+ var maxAge = options.maxAge || null
+
+ var dispose = options.dispose
+
+ var cache = Object.create(null) // hash of items by key
+ , lruList = Object.create(null) // list of items in order of use recency
+ , mru = 0 // most recently used
+ , lru = 0 // least recently used
+ , length = 0 // number of items in the list
+ , itemCount = 0
+
+
+ // resize the cache when the max changes.
+ Object.defineProperty(this, "max",
+ { set : function (mL) {
+ if (!mL || !(typeof mL === "number") || mL <= 0 ) mL = Infinity
+ max = mL
+ // if it gets above double max, trim right away.
+ // otherwise, do it whenever it's convenient.
+ if (length > max) trim()
+ }
+ , get : function () { return max }
+ , enumerable : true
+ })
+
+ // resize the cache when the lengthCalculator changes.
+ Object.defineProperty(this, "lengthCalculator",
+ { set : function (lC) {
+ if (typeof lC !== "function") {
+ lengthCalculator = naiveLength
+ length = itemCount
+ for (var key in cache) {
+ cache[key].length = 1
+ }
+ } else {
+ lengthCalculator = lC
+ length = 0
+ for (var key in cache) {
+ cache[key].length = lengthCalculator(cache[key].value)
+ length += cache[key].length
+ }
+ }
+
+ if (length > max) trim()
+ }
+ , get : function () { return lengthCalculator }
+ , enumerable : true
+ })
+
+ Object.defineProperty(this, "length",
+ { get : function () { return length }
+ , enumerable : true
+ })
+
+
+ Object.defineProperty(this, "itemCount",
+ { get : function () { return itemCount }
+ , enumerable : true
+ })
+
+ this.forEach = function (fn, thisp) {
+ thisp = thisp || this
+ var i = 0;
+ for (var k = mru - 1; k >= 0 && i < itemCount; k--) if (lruList[k]) {
+ i++
+ var hit = lruList[k]
+ fn.call(thisp, hit.value, hit.key, this)
+ }
+ }
+
+ this.keys = function () {
+ var keys = new Array(itemCount)
+ var i = 0
+ for (var k = mru - 1; k >= 0 && i < itemCount; k--) if (lruList[k]) {
+ var hit = lruList[k]
+ keys[i++] = hit.key
+ }
+ return keys
+ }
+
+ this.values = function () {
+ var values = new Array(itemCount)
+ var i = 0
+ for (var k = mru - 1; k >= 0 && i < itemCount; k--) if (lruList[k]) {
+ var hit = lruList[k]
+ values[i++] = hit.value
+ }
+ return values
+ }
+
+ this.reset = function () {
+ if (dispose) {
+ for (var k in cache) {
+ dispose(k, cache[k].value)
+ }
+ }
+ cache = {}
+ lruList = {}
+ lru = 0
+ mru = 0
+ length = 0
+ itemCount = 0
+ }
+
+ // Provided for debugging/dev purposes only. No promises whatsoever that
+ // this API stays stable.
+ this.dump = function () {
+ return cache
+ }
+
+ this.dumpLru = function () {
+ return lruList
+ }
+
+ this.set = function (key, value) {
+ if (hOP(cache, key)) {
+ // dispose of the old one before overwriting
+ if (dispose) dispose(key, cache[key].value)
+ if (maxAge) cache[key].now = Date.now()
+ cache[key].value = value
+ this.get(key)
+ return true
+ }
+
+ var len = lengthCalculator(value)
+ var age = maxAge ? Date.now() : 0
+ var hit = new Entry(key, value, mru++, len, age)
+
+ // oversized objects fall out of cache automatically.
+ if (hit.length > max) {
+ if (dispose) dispose(key, value)
+ return false
+ }
+
+ length += hit.length
+ lruList[hit.lu] = cache[key] = hit
+ itemCount ++
+
+ if (length > max) trim()
+ return true
+ }
+
+ this.has = function (key) {
+ if (!hOP(cache, key)) return false
+ var hit = cache[key]
+ if (maxAge && (Date.now() - hit.now > maxAge)) {
+ return false
+ }
+ return true
+ }
+
+ this.get = function (key) {
+ return get(key, true)
+ }
+
+ this.peek = function (key) {
+ return get(key, false)
+ }
+
+ function get (key, doUse) {
+ var hit = cache[key]
+ if (hit) {
+ if (maxAge && (Date.now() - hit.now > maxAge)) {
+ del(hit)
+ if (!allowStale) hit = undefined
+ } else {
+ if (doUse) use(hit)
+ }
+ if (hit) hit = hit.value
+ }
+ return hit
+ }
+
+ function use (hit) {
+ shiftLU(hit)
+ hit.lu = mru ++
+ lruList[hit.lu] = hit
+ }
+
+ this.del = function (key) {
+ del(cache[key])
+ }
+
+ function trim () {
+ while (lru < mru && length > max)
+ del(lruList[lru])
+ }
+
+ function shiftLU(hit) {
+ delete lruList[ hit.lu ]
+ while (lru < mru && !lruList[lru]) lru ++
+ }
+
+ function del(hit) {
+ if (hit) {
+ if (dispose) dispose(hit.key, hit.value)
+ length -= hit.length
+ itemCount --
+ delete cache[ hit.key ]
+ shiftLU(hit)
+ }
+ }
+}
+
+// classy, since V8 prefers predictable objects.
+function Entry (key, value, mru, len, age) {
+ this.key = key
+ this.value = value
+ this.lu = mru
+ this.length = len
+ this.now = age
+}
+
+})()
http://git-wip-us.apache.org/repos/asf/cordova-blackberry/blob/1139813c/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/package.json
----------------------------------------------------------------------
diff --git a/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/package.json b/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/package.json
new file mode 100644
index 0000000..73920bf
--- /dev/null
+++ b/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/package.json
@@ -0,0 +1,62 @@
+{
+ "name": "lru-cache",
+ "description": "A cache object that deletes the least-recently-used items.",
+ "version": "2.3.0",
+ "author": {
+ "name": "Isaac Z. Schlueter",
+ "email": "i@izs.me"
+ },
+ "scripts": {
+ "test": "tap test --gc"
+ },
+ "main": "lib/lru-cache.js",
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/isaacs/node-lru-cache.git"
+ },
+ "devDependencies": {
+ "tap": "",
+ "weak": ""
+ },
+ "license": {
+ "type": "MIT",
+ "url": "http://github.com/isaacs/node-lru-cache/raw/master/LICENSE"
+ },
+ "contributors": [
+ {
+ "name": "Isaac Z. Schlueter",
+ "email": "i@izs.me"
+ },
+ {
+ "name": "Carlos Brito Lage",
+ "email": "carlos@carloslage.net"
+ },
+ {
+ "name": "Marko Mikulicic",
+ "email": "marko.mikulicic@isti.cnr.it"
+ },
+ {
+ "name": "Trent Mick",
+ "email": "trentm@gmail.com"
+ },
+ {
+ "name": "Kevin O'Hara",
+ "email": "kevinohara80@gmail.com"
+ },
+ {
+ "name": "Marco Rogers",
+ "email": "marco.rogers@gmail.com"
+ },
+ {
+ "name": "Jesse Dailey",
+ "email": "jesse.dailey@gmail.com"
+ }
+ ],
+ "readme": "# lru cache\n\nA cache object that deletes the least-recently-used items.\n\n## Usage:\n\n```javascript\nvar LRU = require(\"lru-cache\")\n , options = { max: 500\n , length: function (n) { return n * 2 }\n , dispose: function (key, n) { n.close() }\n , maxAge: 1000 * 60 * 60 }\n , cache = LRU(options)\n , otherCache = LRU(50) // sets just the max size\n\ncache.set(\"key\", \"value\")\ncache.get(\"key\") // \"value\"\n\ncache.reset() // empty the cache\n```\n\nIf you put more stuff in it, then items will fall out.\n\nIf you try to put an oversized thing in it, then it'll fall out right\naway.\n\n## Options\n\n* `max` The maximum size of the cache, checked by applying the length\n function to all values in the cache. Not setting this is kind of\n silly, since that's the whole purpose of this lib, but it defaults\n to `Infinity`.\n* `maxAge` Maximum age in ms. Items are not pro-actively pruned out\n as they age, but if yo
u try to get an item that is too old, it'll\n drop it and return undefined instead of giving it to you.\n* `length` Function that is used to calculate the length of stored\n items. If you're storing strings or buffers, then you probably want\n to do something like `function(n){return n.length}`. The default is\n `function(n){return 1}`, which is fine if you want to store `n`\n like-sized things.\n* `dispose` Function that is called on items when they are dropped\n from the cache. This can be handy if you want to close file\n descriptors or do other cleanup tasks when items are no longer\n accessible. Called with `key, value`. It's called *before*\n actually removing the item from the internal cache, so if you want\n to immediately put it back in, you'll have to do that in a\n `nextTick` or `setTimeout` callback or it won't do anything.\n* `stale` By default, if you set a `maxAge`, it'll only actually pull\n stale items out of the cache when you `get(key)`. (That is
, it's\n not pre-emptively doing a `setTimeout` or anything.) If you set\n `stale:true`, it'll return the stale value before deleting it. If\n you don't set this, then it'll return `undefined` when you try to\n get a stale entry, as if it had already been deleted.\n\n## API\n\n* `set(key, value)`\n* `get(key) => value`\n\n Both of these will update the \"recently used\"-ness of the key.\n They do what you think.\n\n* `peek(key)`\n\n Returns the key value (or `undefined` if not found) without\n updating the \"recently used\"-ness of the key.\n\n (If you find yourself using this a lot, you *might* be using the\n wrong sort of data structure, but there are some use cases where\n it's handy.)\n\n* `del(key)`\n\n Deletes a key out of the cache.\n\n* `reset()`\n\n Clear the cache entirely, throwing away all values.\n\n* `has(key)`\n\n Check if a key is in the cache, without updating the recent-ness\n or deleting it for being stale.\n\n* `forEach(func
tion(value,key,cache), [thisp])`\n\n Just like `Array.prototype.forEach`. Iterates over all the keys\n in the cache, in order of recent-ness. (Ie, more recently used\n items are iterated over first.)\n\n* `keys()`\n\n Return an array of the keys in the cache.\n\n* `values()`\n\n Return an array of the values in the cache.\n",
+ "readmeFilename": "README.md",
+ "bugs": {
+ "url": "https://github.com/isaacs/node-lru-cache/issues"
+ },
+ "_id": "lru-cache@2.3.0",
+ "_from": "lru-cache@2"
+}
http://git-wip-us.apache.org/repos/asf/cordova-blackberry/blob/1139813c/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/s.js
----------------------------------------------------------------------
diff --git a/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/s.js b/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/s.js
new file mode 100644
index 0000000..c2a9e54
--- /dev/null
+++ b/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/s.js
@@ -0,0 +1,25 @@
+var LRU = require('lru-cache');
+
+var max = +process.argv[2] || 10240;
+var more = 1024;
+
+var cache = LRU({
+ max: max, maxAge: 86400e3
+});
+
+// fill cache
+for (var i = 0; i < max; ++i) {
+ cache.set(i, {});
+}
+
+var start = process.hrtime();
+
+// adding more items
+for ( ; i < max+more; ++i) {
+ cache.set(i, {});
+}
+
+var end = process.hrtime(start);
+var msecs = end[0] * 1E3 + end[1] / 1E6;
+
+console.log('adding %d items took %d ms', more, msecs.toPrecision(5));
http://git-wip-us.apache.org/repos/asf/cordova-blackberry/blob/1139813c/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/test/basic.js
----------------------------------------------------------------------
diff --git a/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/test/basic.js b/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/test/basic.js
new file mode 100644
index 0000000..70f3f8b
--- /dev/null
+++ b/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/test/basic.js
@@ -0,0 +1,329 @@
+var test = require("tap").test
+ , LRU = require("../")
+
+test("basic", function (t) {
+ var cache = new LRU({max: 10})
+ cache.set("key", "value")
+ t.equal(cache.get("key"), "value")
+ t.equal(cache.get("nada"), undefined)
+ t.equal(cache.length, 1)
+ t.equal(cache.max, 10)
+ t.end()
+})
+
+test("least recently set", function (t) {
+ var cache = new LRU(2)
+ cache.set("a", "A")
+ cache.set("b", "B")
+ cache.set("c", "C")
+ t.equal(cache.get("c"), "C")
+ t.equal(cache.get("b"), "B")
+ t.equal(cache.get("a"), undefined)
+ t.end()
+})
+
+test("lru recently gotten", function (t) {
+ var cache = new LRU(2)
+ cache.set("a", "A")
+ cache.set("b", "B")
+ cache.get("a")
+ cache.set("c", "C")
+ t.equal(cache.get("c"), "C")
+ t.equal(cache.get("b"), undefined)
+ t.equal(cache.get("a"), "A")
+ t.end()
+})
+
+test("del", function (t) {
+ var cache = new LRU(2)
+ cache.set("a", "A")
+ cache.del("a")
+ t.equal(cache.get("a"), undefined)
+ t.end()
+})
+
+test("max", function (t) {
+ var cache = new LRU(3)
+
+ // test changing the max, verify that the LRU items get dropped.
+ cache.max = 100
+ for (var i = 0; i < 100; i ++) cache.set(i, i)
+ t.equal(cache.length, 100)
+ for (var i = 0; i < 100; i ++) {
+ t.equal(cache.get(i), i)
+ }
+ cache.max = 3
+ t.equal(cache.length, 3)
+ for (var i = 0; i < 97; i ++) {
+ t.equal(cache.get(i), undefined)
+ }
+ for (var i = 98; i < 100; i ++) {
+ t.equal(cache.get(i), i)
+ }
+
+ // now remove the max restriction, and try again.
+ cache.max = "hello"
+ for (var i = 0; i < 100; i ++) cache.set(i, i)
+ t.equal(cache.length, 100)
+ for (var i = 0; i < 100; i ++) {
+ t.equal(cache.get(i), i)
+ }
+ // should trigger an immediate resize
+ cache.max = 3
+ t.equal(cache.length, 3)
+ for (var i = 0; i < 97; i ++) {
+ t.equal(cache.get(i), undefined)
+ }
+ for (var i = 98; i < 100; i ++) {
+ t.equal(cache.get(i), i)
+ }
+ t.end()
+})
+
+test("reset", function (t) {
+ var cache = new LRU(10)
+ cache.set("a", "A")
+ cache.set("b", "B")
+ cache.reset()
+ t.equal(cache.length, 0)
+ t.equal(cache.max, 10)
+ t.equal(cache.get("a"), undefined)
+ t.equal(cache.get("b"), undefined)
+ t.end()
+})
+
+
+// Note: `<cache>.dump()` is a debugging tool only. No guarantees are made
+// about the format/layout of the response.
+test("dump", function (t) {
+ var cache = new LRU(10)
+ var d = cache.dump();
+ t.equal(Object.keys(d).length, 0, "nothing in dump for empty cache")
+ cache.set("a", "A")
+ var d = cache.dump() // { a: { key: "a", value: "A", lu: 0 } }
+ t.ok(d.a)
+ t.equal(d.a.key, "a")
+ t.equal(d.a.value, "A")
+ t.equal(d.a.lu, 0)
+
+ cache.set("b", "B")
+ cache.get("b")
+ d = cache.dump()
+ t.ok(d.b)
+ t.equal(d.b.key, "b")
+ t.equal(d.b.value, "B")
+ t.equal(d.b.lu, 2)
+
+ t.end()
+})
+
+
+test("basic with weighed length", function (t) {
+ var cache = new LRU({
+ max: 100,
+ length: function (item) { return item.size }
+ })
+ cache.set("key", {val: "value", size: 50})
+ t.equal(cache.get("key").val, "value")
+ t.equal(cache.get("nada"), undefined)
+ t.equal(cache.lengthCalculator(cache.get("key")), 50)
+ t.equal(cache.length, 50)
+ t.equal(cache.max, 100)
+ t.end()
+})
+
+
+test("weighed length item too large", function (t) {
+ var cache = new LRU({
+ max: 10,
+ length: function (item) { return item.size }
+ })
+ t.equal(cache.max, 10)
+
+ // should fall out immediately
+ cache.set("key", {val: "value", size: 50})
+
+ t.equal(cache.length, 0)
+ t.equal(cache.get("key"), undefined)
+ t.end()
+})
+
+test("least recently set with weighed length", function (t) {
+ var cache = new LRU({
+ max:8,
+ length: function (item) { return item.length }
+ })
+ cache.set("a", "A")
+ cache.set("b", "BB")
+ cache.set("c", "CCC")
+ cache.set("d", "DDDD")
+ t.equal(cache.get("d"), "DDDD")
+ t.equal(cache.get("c"), "CCC")
+ t.equal(cache.get("b"), undefined)
+ t.equal(cache.get("a"), undefined)
+ t.end()
+})
+
+test("lru recently gotten with weighed length", function (t) {
+ var cache = new LRU({
+ max: 8,
+ length: function (item) { return item.length }
+ })
+ cache.set("a", "A")
+ cache.set("b", "BB")
+ cache.set("c", "CCC")
+ cache.get("a")
+ cache.get("b")
+ cache.set("d", "DDDD")
+ t.equal(cache.get("c"), undefined)
+ t.equal(cache.get("d"), "DDDD")
+ t.equal(cache.get("b"), "BB")
+ t.equal(cache.get("a"), "A")
+ t.end()
+})
+
+test("set returns proper booleans", function(t) {
+ var cache = new LRU({
+ max: 5,
+ length: function (item) { return item.length }
+ })
+
+ t.equal(cache.set("a", "A"), true)
+
+ // should return false for max exceeded
+ t.equal(cache.set("b", "donuts"), false)
+
+ t.equal(cache.set("b", "B"), true)
+ t.equal(cache.set("c", "CCCC"), true)
+ t.end()
+})
+
+test("drop the old items", function(t) {
+ var cache = new LRU({
+ max: 5,
+ maxAge: 50
+ })
+
+ cache.set("a", "A")
+
+ setTimeout(function () {
+ cache.set("b", "b")
+ t.equal(cache.get("a"), "A")
+ }, 25)
+
+ setTimeout(function () {
+ cache.set("c", "C")
+ // timed out
+ t.notOk(cache.get("a"))
+ }, 60)
+
+ setTimeout(function () {
+ t.notOk(cache.get("b"))
+ t.equal(cache.get("c"), "C")
+ }, 90)
+
+ setTimeout(function () {
+ t.notOk(cache.get("c"))
+ t.end()
+ }, 155)
+})
+
+test("disposal function", function(t) {
+ var disposed = false
+ var cache = new LRU({
+ max: 1,
+ dispose: function (k, n) {
+ disposed = n
+ }
+ })
+
+ cache.set(1, 1)
+ cache.set(2, 2)
+ t.equal(disposed, 1)
+ cache.set(3, 3)
+ t.equal(disposed, 2)
+ cache.reset()
+ t.equal(disposed, 3)
+ t.end()
+})
+
+test("disposal function on too big of item", function(t) {
+ var disposed = false
+ var cache = new LRU({
+ max: 1,
+ length: function (k) {
+ return k.length
+ },
+ dispose: function (k, n) {
+ disposed = n
+ }
+ })
+ var obj = [ 1, 2 ]
+
+ t.equal(disposed, false)
+ cache.set("obj", obj)
+ t.equal(disposed, obj)
+ t.end()
+})
+
+test("has()", function(t) {
+ var cache = new LRU({
+ max: 1,
+ maxAge: 10
+ })
+
+ cache.set('foo', 'bar')
+ t.equal(cache.has('foo'), true)
+ cache.set('blu', 'baz')
+ t.equal(cache.has('foo'), false)
+ t.equal(cache.has('blu'), true)
+ setTimeout(function() {
+ t.equal(cache.has('blu'), false)
+ t.end()
+ }, 15)
+})
+
+test("stale", function(t) {
+ var cache = new LRU({
+ maxAge: 10,
+ stale: true
+ })
+
+ cache.set('foo', 'bar')
+ t.equal(cache.get('foo'), 'bar')
+ t.equal(cache.has('foo'), true)
+ setTimeout(function() {
+ t.equal(cache.has('foo'), false)
+ t.equal(cache.get('foo'), 'bar')
+ t.equal(cache.get('foo'), undefined)
+ t.end()
+ }, 15)
+})
+
+test("lru update via set", function(t) {
+ var cache = LRU({ max: 2 });
+
+ cache.set('foo', 1);
+ cache.set('bar', 2);
+ cache.del('bar');
+ cache.set('baz', 3);
+ cache.set('qux', 4);
+
+ t.equal(cache.get('foo'), undefined)
+ t.equal(cache.get('bar'), undefined)
+ t.equal(cache.get('baz'), 3)
+ t.equal(cache.get('qux'), 4)
+ t.end()
+})
+
+test("least recently set w/ peek", function (t) {
+ var cache = new LRU(2)
+ cache.set("a", "A")
+ cache.set("b", "B")
+ t.equal(cache.peek("a"), "A")
+ cache.set("c", "C")
+ t.equal(cache.get("c"), "C")
+ t.equal(cache.get("b"), "B")
+ t.equal(cache.get("a"), undefined)
+ t.end()
+})
http://git-wip-us.apache.org/repos/asf/cordova-blackberry/blob/1139813c/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/test/foreach.js
----------------------------------------------------------------------
diff --git a/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/test/foreach.js b/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/test/foreach.js
new file mode 100644
index 0000000..eefb80d
--- /dev/null
+++ b/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/test/foreach.js
@@ -0,0 +1,52 @@
+var test = require('tap').test
+var LRU = require('../')
+
+test('forEach', function (t) {
+ var l = new LRU(5)
+ for (var i = 0; i < 10; i ++) {
+ l.set(i.toString(), i.toString(2))
+ }
+
+ var i = 9
+ l.forEach(function (val, key, cache) {
+ t.equal(cache, l)
+ t.equal(key, i.toString())
+ t.equal(val, i.toString(2))
+ i -= 1
+ })
+
+ // get in order of most recently used
+ l.get(6)
+ l.get(8)
+
+ var order = [ 8, 6, 9, 7, 5 ]
+ var i = 0
+
+ l.forEach(function (val, key, cache) {
+ var j = order[i ++]
+ t.equal(cache, l)
+ t.equal(key, j.toString())
+ t.equal(val, j.toString(2))
+ })
+
+ t.end()
+})
+
+test('keys() and values()', function (t) {
+ var l = new LRU(5)
+ for (var i = 0; i < 10; i ++) {
+ l.set(i.toString(), i.toString(2))
+ }
+
+ t.similar(l.keys(), ['9', '8', '7', '6', '5'])
+ t.similar(l.values(), ['1001', '1000', '111', '110', '101'])
+
+ // get in order of most recently used
+ l.get(6)
+ l.get(8)
+
+ t.similar(l.keys(), ['8', '6', '9', '7', '5'])
+ t.similar(l.values(), ['1000', '110', '1001', '111', '101'])
+
+ t.end()
+})
http://git-wip-us.apache.org/repos/asf/cordova-blackberry/blob/1139813c/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/test/memory-leak.js
----------------------------------------------------------------------
diff --git a/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/test/memory-leak.js b/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/test/memory-leak.js
new file mode 100644
index 0000000..7af45b0
--- /dev/null
+++ b/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/lru-cache/test/memory-leak.js
@@ -0,0 +1,50 @@
+#!/usr/bin/env node --expose_gc
+
+var weak = require('weak');
+var test = require('tap').test
+var LRU = require('../')
+var l = new LRU({ max: 10 })
+var refs = 0
+function X() {
+ refs ++
+ weak(this, deref)
+}
+
+function deref() {
+ refs --
+}
+
+test('no leaks', function (t) {
+ // fill up the cache
+ for (var i = 0; i < 100; i++) {
+ l.set(i, new X);
+ // throw some gets in there, too.
+ if (i % 2 === 0)
+ l.get(i / 2)
+ }
+
+ gc()
+
+ var start = process.memoryUsage()
+
+ // capture the memory
+ var startRefs = refs
+
+ // do it again, but more
+ for (var i = 0; i < 10000; i++) {
+ l.set(i, new X);
+ // throw some gets in there, too.
+ if (i % 2 === 0)
+ l.get(i / 2)
+ }
+
+ gc()
+
+ var end = process.memoryUsage()
+ t.equal(refs, startRefs, 'no leaky refs')
+
+ console.error('start: %j\n' +
+ 'end: %j', start, end);
+ t.pass();
+ t.end();
+})
http://git-wip-us.apache.org/repos/asf/cordova-blackberry/blob/1139813c/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/sigmund/LICENSE
----------------------------------------------------------------------
diff --git a/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/sigmund/LICENSE b/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/sigmund/LICENSE
new file mode 100644
index 0000000..0c44ae7
--- /dev/null
+++ b/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/sigmund/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) Isaac Z. Schlueter ("Author")
+All rights reserved.
+
+The BSD License
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS
+BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
http://git-wip-us.apache.org/repos/asf/cordova-blackberry/blob/1139813c/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/sigmund/README.md
----------------------------------------------------------------------
diff --git a/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/sigmund/README.md b/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/sigmund/README.md
new file mode 100644
index 0000000..7e36512
--- /dev/null
+++ b/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/sigmund/README.md
@@ -0,0 +1,53 @@
+# sigmund
+
+Quick and dirty signatures for Objects.
+
+This is like a much faster `deepEquals` comparison, which returns a
+string key suitable for caches and the like.
+
+## Usage
+
+```javascript
+function doSomething (someObj) {
+ var key = sigmund(someObj, maxDepth) // max depth defaults to 10
+ var cached = cache.get(key)
+ if (cached) return cached)
+
+ var result = expensiveCalculation(someObj)
+ cache.set(key, result)
+ return result
+}
+```
+
+The resulting key will be as unique and reproducible as calling
+`JSON.stringify` or `util.inspect` on the object, but is much faster.
+In order to achieve this speed, some differences are glossed over.
+For example, the object `{0:'foo'}` will be treated identically to the
+array `['foo']`.
+
+Also, just as there is no way to summon the soul from the scribblings
+of a cocain-addled psychoanalyst, there is no way to revive the object
+from the signature string that sigmund gives you. In fact, it's
+barely even readable.
+
+As with `sys.inspect` and `JSON.stringify`, larger objects will
+produce larger signature strings.
+
+Because sigmund is a bit less strict than the more thorough
+alternatives, the strings will be shorter, and also there is a
+slightly higher chance for collisions. For example, these objects
+have the same signature:
+
+ var obj1 = {a:'b',c:/def/,g:['h','i',{j:'',k:'l'}]}
+ var obj2 = {a:'b',c:'/def/',g:['h','i','{jkl']}
+
+Like a good Freudian, sigmund is most effective when you already have
+some understanding of what you're looking for. It can help you help
+yourself, but you must be willing to do some work as well.
+
+Cycles are handled, and cyclical objects are silently omitted (though
+the key is included in the signature output.)
+
+The second argument is the maximum depth, which defaults to 10,
+because that is the maximum object traversal depth covered by most
+insurance carriers.
http://git-wip-us.apache.org/repos/asf/cordova-blackberry/blob/1139813c/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/sigmund/bench.js
----------------------------------------------------------------------
diff --git a/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/sigmund/bench.js b/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/sigmund/bench.js
new file mode 100644
index 0000000..5acfd6d
--- /dev/null
+++ b/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/sigmund/bench.js
@@ -0,0 +1,283 @@
+// different ways to id objects
+// use a req/res pair, since it's crazy deep and cyclical
+
+// sparseFE10 and sigmund are usually pretty close, which is to be expected,
+// since they are essentially the same algorithm, except that sigmund handles
+// regular expression objects properly.
+
+
+var http = require('http')
+var util = require('util')
+var sigmund = require('./sigmund.js')
+var sreq, sres, creq, cres, test
+
+http.createServer(function (q, s) {
+ sreq = q
+ sres = s
+ sres.end('ok')
+ this.close(function () { setTimeout(function () {
+ start()
+ }, 200) })
+}).listen(1337, function () {
+ creq = http.get({ port: 1337 })
+ creq.on('response', function (s) { cres = s })
+})
+
+function start () {
+ test = [sreq, sres, creq, cres]
+ // test = sreq
+ // sreq.sres = sres
+ // sreq.creq = creq
+ // sreq.cres = cres
+
+ for (var i in exports.compare) {
+ console.log(i)
+ var hash = exports.compare[i]()
+ console.log(hash)
+ console.log(hash.length)
+ console.log('')
+ }
+
+ require('bench').runMain()
+}
+
+function customWs (obj, md, d) {
+ d = d || 0
+ var to = typeof obj
+ if (to === 'undefined' || to === 'function' || to === null) return ''
+ if (d > md || !obj || to !== 'object') return ('' + obj).replace(/[\n ]+/g, '')
+
+ if (Array.isArray(obj)) {
+ return obj.map(function (i, _, __) {
+ return customWs(i, md, d + 1)
+ }).reduce(function (a, b) { return a + b }, '')
+ }
+
+ var keys = Object.keys(obj)
+ return keys.map(function (k, _, __) {
+ return k + ':' + customWs(obj[k], md, d + 1)
+ }).reduce(function (a, b) { return a + b }, '')
+}
+
+function custom (obj, md, d) {
+ d = d || 0
+ var to = typeof obj
+ if (to === 'undefined' || to === 'function' || to === null) return ''
+ if (d > md || !obj || to !== 'object') return '' + obj
+
+ if (Array.isArray(obj)) {
+ return obj.map(function (i, _, __) {
+ return custom(i, md, d + 1)
+ }).reduce(function (a, b) { return a + b }, '')
+ }
+
+ var keys = Object.keys(obj)
+ return keys.map(function (k, _, __) {
+ return k + ':' + custom(obj[k], md, d + 1)
+ }).reduce(function (a, b) { return a + b }, '')
+}
+
+function sparseFE2 (obj, maxDepth) {
+ var seen = []
+ var soFar = ''
+ function ch (v, depth) {
+ if (depth > maxDepth) return
+ if (typeof v === 'function' || typeof v === 'undefined') return
+ if (typeof v !== 'object' || !v) {
+ soFar += v
+ return
+ }
+ if (seen.indexOf(v) !== -1 || depth === maxDepth) return
+ seen.push(v)
+ soFar += '{'
+ Object.keys(v).forEach(function (k, _, __) {
+ // pseudo-private values. skip those.
+ if (k.charAt(0) === '_') return
+ var to = typeof v[k]
+ if (to === 'function' || to === 'undefined') return
+ soFar += k + ':'
+ ch(v[k], depth + 1)
+ })
+ soFar += '}'
+ }
+ ch(obj, 0)
+ return soFar
+}
+
+function sparseFE (obj, maxDepth) {
+ var seen = []
+ var soFar = ''
+ function ch (v, depth) {
+ if (depth > maxDepth) return
+ if (typeof v === 'function' || typeof v === 'undefined') return
+ if (typeof v !== 'object' || !v) {
+ soFar += v
+ return
+ }
+ if (seen.indexOf(v) !== -1 || depth === maxDepth) return
+ seen.push(v)
+ soFar += '{'
+ Object.keys(v).forEach(function (k, _, __) {
+ // pseudo-private values. skip those.
+ if (k.charAt(0) === '_') return
+ var to = typeof v[k]
+ if (to === 'function' || to === 'undefined') return
+ soFar += k
+ ch(v[k], depth + 1)
+ })
+ }
+ ch(obj, 0)
+ return soFar
+}
+
+function sparse (obj, maxDepth) {
+ var seen = []
+ var soFar = ''
+ function ch (v, depth) {
+ if (depth > maxDepth) return
+ if (typeof v === 'function' || typeof v === 'undefined') return
+ if (typeof v !== 'object' || !v) {
+ soFar += v
+ return
+ }
+ if (seen.indexOf(v) !== -1 || depth === maxDepth) return
+ seen.push(v)
+ soFar += '{'
+ for (var k in v) {
+ // pseudo-private values. skip those.
+ if (k.charAt(0) === '_') continue
+ var to = typeof v[k]
+ if (to === 'function' || to === 'undefined') continue
+ soFar += k
+ ch(v[k], depth + 1)
+ }
+ }
+ ch(obj, 0)
+ return soFar
+}
+
+function noCommas (obj, maxDepth) {
+ var seen = []
+ var soFar = ''
+ function ch (v, depth) {
+ if (depth > maxDepth) return
+ if (typeof v === 'function' || typeof v === 'undefined') return
+ if (typeof v !== 'object' || !v) {
+ soFar += v
+ return
+ }
+ if (seen.indexOf(v) !== -1 || depth === maxDepth) return
+ seen.push(v)
+ soFar += '{'
+ for (var k in v) {
+ // pseudo-private values. skip those.
+ if (k.charAt(0) === '_') continue
+ var to = typeof v[k]
+ if (to === 'function' || to === 'undefined') continue
+ soFar += k + ':'
+ ch(v[k], depth + 1)
+ }
+ soFar += '}'
+ }
+ ch(obj, 0)
+ return soFar
+}
+
+
+function flatten (obj, maxDepth) {
+ var seen = []
+ var soFar = ''
+ function ch (v, depth) {
+ if (depth > maxDepth) return
+ if (typeof v === 'function' || typeof v === 'undefined') return
+ if (typeof v !== 'object' || !v) {
+ soFar += v
+ return
+ }
+ if (seen.indexOf(v) !== -1 || depth === maxDepth) return
+ seen.push(v)
+ soFar += '{'
+ for (var k in v) {
+ // pseudo-private values. skip those.
+ if (k.charAt(0) === '_') continue
+ var to = typeof v[k]
+ if (to === 'function' || to === 'undefined') continue
+ soFar += k + ':'
+ ch(v[k], depth + 1)
+ soFar += ','
+ }
+ soFar += '}'
+ }
+ ch(obj, 0)
+ return soFar
+}
+
+exports.compare =
+{
+ // 'custom 2': function () {
+ // return custom(test, 2, 0)
+ // },
+ // 'customWs 2': function () {
+ // return customWs(test, 2, 0)
+ // },
+ 'JSON.stringify (guarded)': function () {
+ var seen = []
+ return JSON.stringify(test, function (k, v) {
+ if (typeof v !== 'object' || !v) return v
+ if (seen.indexOf(v) !== -1) return undefined
+ seen.push(v)
+ return v
+ })
+ },
+
+ 'flatten 10': function () {
+ return flatten(test, 10)
+ },
+
+ // 'flattenFE 10': function () {
+ // return flattenFE(test, 10)
+ // },
+
+ 'noCommas 10': function () {
+ return noCommas(test, 10)
+ },
+
+ 'sparse 10': function () {
+ return sparse(test, 10)
+ },
+
+ 'sparseFE 10': function () {
+ return sparseFE(test, 10)
+ },
+
+ 'sparseFE2 10': function () {
+ return sparseFE2(test, 10)
+ },
+
+ sigmund: function() {
+ return sigmund(test, 10)
+ },
+
+
+ // 'util.inspect 1': function () {
+ // return util.inspect(test, false, 1, false)
+ // },
+ // 'util.inspect undefined': function () {
+ // util.inspect(test)
+ // },
+ // 'util.inspect 2': function () {
+ // util.inspect(test, false, 2, false)
+ // },
+ // 'util.inspect 3': function () {
+ // util.inspect(test, false, 3, false)
+ // },
+ // 'util.inspect 4': function () {
+ // util.inspect(test, false, 4, false)
+ // },
+ // 'util.inspect Infinity': function () {
+ // util.inspect(test, false, Infinity, false)
+ // }
+}
+
+/** results
+**/
http://git-wip-us.apache.org/repos/asf/cordova-blackberry/blob/1139813c/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/sigmund/package.json
----------------------------------------------------------------------
diff --git a/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/sigmund/package.json b/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/sigmund/package.json
new file mode 100644
index 0000000..ec8e2eb
--- /dev/null
+++ b/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/sigmund/package.json
@@ -0,0 +1,41 @@
+{
+ "name": "sigmund",
+ "version": "1.0.0",
+ "description": "Quick and dirty signatures for Objects.",
+ "main": "sigmund.js",
+ "directories": {
+ "test": "test"
+ },
+ "dependencies": {},
+ "devDependencies": {
+ "tap": "~0.3.0"
+ },
+ "scripts": {
+ "test": "tap test/*.js",
+ "bench": "node bench.js"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/isaacs/sigmund"
+ },
+ "keywords": [
+ "object",
+ "signature",
+ "key",
+ "data",
+ "psychoanalysis"
+ ],
+ "author": {
+ "name": "Isaac Z. Schlueter",
+ "email": "i@izs.me",
+ "url": "http://blog.izs.me/"
+ },
+ "license": "BSD",
+ "readme": "# sigmund\n\nQuick and dirty signatures for Objects.\n\nThis is like a much faster `deepEquals` comparison, which returns a\nstring key suitable for caches and the like.\n\n## Usage\n\n```javascript\nfunction doSomething (someObj) {\n var key = sigmund(someObj, maxDepth) // max depth defaults to 10\n var cached = cache.get(key)\n if (cached) return cached)\n\n var result = expensiveCalculation(someObj)\n cache.set(key, result)\n return result\n}\n```\n\nThe resulting key will be as unique and reproducible as calling\n`JSON.stringify` or `util.inspect` on the object, but is much faster.\nIn order to achieve this speed, some differences are glossed over.\nFor example, the object `{0:'foo'}` will be treated identically to the\narray `['foo']`.\n\nAlso, just as there is no way to summon the soul from the scribblings\nof a cocain-addled psychoanalyst, there is no way to revive the object\nfrom the signature string that sigmund gives you. In fact, it's\nbarely even rea
dable.\n\nAs with `sys.inspect` and `JSON.stringify`, larger objects will\nproduce larger signature strings.\n\nBecause sigmund is a bit less strict than the more thorough\nalternatives, the strings will be shorter, and also there is a\nslightly higher chance for collisions. For example, these objects\nhave the same signature:\n\n var obj1 = {a:'b',c:/def/,g:['h','i',{j:'',k:'l'}]}\n var obj2 = {a:'b',c:'/def/',g:['h','i','{jkl']}\n\nLike a good Freudian, sigmund is most effective when you already have\nsome understanding of what you're looking for. It can help you help\nyourself, but you must be willing to do some work as well.\n\nCycles are handled, and cyclical objects are silently omitted (though\nthe key is included in the signature output.)\n\nThe second argument is the maximum depth, which defaults to 10,\nbecause that is the maximum object traversal depth covered by most\ninsurance carriers.\n",
+ "readmeFilename": "README.md",
+ "bugs": {
+ "url": "https://github.com/isaacs/sigmund/issues"
+ },
+ "_id": "sigmund@1.0.0",
+ "_from": "sigmund@~1.0.0"
+}
http://git-wip-us.apache.org/repos/asf/cordova-blackberry/blob/1139813c/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/sigmund/sigmund.js
----------------------------------------------------------------------
diff --git a/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/sigmund/sigmund.js b/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/sigmund/sigmund.js
new file mode 100644
index 0000000..82c7ab8
--- /dev/null
+++ b/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/sigmund/sigmund.js
@@ -0,0 +1,39 @@
+module.exports = sigmund
+function sigmund (subject, maxSessions) {
+ maxSessions = maxSessions || 10;
+ var notes = [];
+ var analysis = '';
+ var RE = RegExp;
+
+ function psychoAnalyze (subject, session) {
+ if (session > maxSessions) return;
+
+ if (typeof subject === 'function' ||
+ typeof subject === 'undefined') {
+ return;
+ }
+
+ if (typeof subject !== 'object' || !subject ||
+ (subject instanceof RE)) {
+ analysis += subject;
+ return;
+ }
+
+ if (notes.indexOf(subject) !== -1 || session === maxSessions) return;
+
+ notes.push(subject);
+ analysis += '{';
+ Object.keys(subject).forEach(function (issue, _, __) {
+ // pseudo-private values. skip those.
+ if (issue.charAt(0) === '_') return;
+ var to = typeof subject[issue];
+ if (to === 'function' || to === 'undefined') return;
+ analysis += issue;
+ psychoAnalyze(subject[issue], session + 1);
+ });
+ }
+ psychoAnalyze(subject, 0);
+ return analysis;
+}
+
+// vim: set softtabstop=4 shiftwidth=4:
http://git-wip-us.apache.org/repos/asf/cordova-blackberry/blob/1139813c/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/sigmund/test/basic.js
----------------------------------------------------------------------
diff --git a/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/sigmund/test/basic.js b/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/sigmund/test/basic.js
new file mode 100644
index 0000000..50c53a1
--- /dev/null
+++ b/blackberry10/node_modules/plugman/node_modules/glob/node_modules/minimatch/node_modules/sigmund/test/basic.js
@@ -0,0 +1,24 @@
+var test = require('tap').test
+var sigmund = require('../sigmund.js')
+
+
+// occasionally there are duplicates
+// that's an acceptable edge-case. JSON.stringify and util.inspect
+// have some collision potential as well, though less, and collision
+// detection is expensive.
+var hash = '{abc/def/g{0h1i2{jkl'
+var obj1 = {a:'b',c:/def/,g:['h','i',{j:'',k:'l'}]}
+var obj2 = {a:'b',c:'/def/',g:['h','i','{jkl']}
+
+var obj3 = JSON.parse(JSON.stringify(obj1))
+obj3.c = /def/
+obj3.g[2].cycle = obj3
+var cycleHash = '{abc/def/g{0h1i2{jklcycle'
+
+test('basic', function (t) {
+ t.equal(sigmund(obj1), hash)
+ t.equal(sigmund(obj2), hash)
+ t.equal(sigmund(obj3), cycleHash)
+ t.end()
+})
+