You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cordova.apache.org by st...@apache.org on 2016/08/01 22:22:50 UTC
[31/61] [abbrv] [partial] cordova-create git commit: gitignore node
modules
http://git-wip-us.apache.org/repos/asf/cordova-create/blob/9fb2883e/node_modules/cordova-fetch/node_modules/minimatch/minimatch.js
----------------------------------------------------------------------
diff --git a/node_modules/cordova-fetch/node_modules/minimatch/minimatch.js b/node_modules/cordova-fetch/node_modules/minimatch/minimatch.js
deleted file mode 100644
index 830a272..0000000
--- a/node_modules/cordova-fetch/node_modules/minimatch/minimatch.js
+++ /dev/null
@@ -1,924 +0,0 @@
-module.exports = minimatch
-minimatch.Minimatch = Minimatch
-
-var path = { sep: '/' }
-try {
- path = require('path')
-} catch (er) {}
-
-var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {}
-var expand = require('brace-expansion')
-
-// any single thing other than /
-// don't need to escape / when using new RegExp()
-var qmark = '[^/]'
-
-// * => any number of characters
-var star = qmark + '*?'
-
-// ** when dots are allowed. Anything goes, except .. and .
-// not (^ or / followed by one or two dots followed by $ or /),
-// followed by anything, any number of times.
-var twoStarDot = '(?:(?!(?:\\\/|^)(?:\\.{1,2})($|\\\/)).)*?'
-
-// not a ^ or / followed by a dot,
-// followed by anything, any number of times.
-var twoStarNoDot = '(?:(?!(?:\\\/|^)\\.).)*?'
-
-// characters that need to be escaped in RegExp.
-var reSpecials = charSet('().*{}+?[]^$\\!')
-
-// "abc" -> { a:true, b:true, c:true }
-function charSet (s) {
- return s.split('').reduce(function (set, c) {
- set[c] = true
- return set
- }, {})
-}
-
-// normalizes slashes.
-var slashSplit = /\/+/
-
-minimatch.filter = filter
-function filter (pattern, options) {
- options = options || {}
- return function (p, i, list) {
- return minimatch(p, pattern, options)
- }
-}
-
-function ext (a, b) {
- a = a || {}
- b = b || {}
- var t = {}
- Object.keys(b).forEach(function (k) {
- t[k] = b[k]
- })
- Object.keys(a).forEach(function (k) {
- t[k] = a[k]
- })
- return t
-}
-
-minimatch.defaults = function (def) {
- if (!def || !Object.keys(def).length) return minimatch
-
- var orig = minimatch
-
- var m = function minimatch (p, pattern, options) {
- return orig.minimatch(p, pattern, ext(def, options))
- }
-
- m.Minimatch = function Minimatch (pattern, options) {
- return new orig.Minimatch(pattern, ext(def, options))
- }
-
- return m
-}
-
-Minimatch.defaults = function (def) {
- if (!def || !Object.keys(def).length) return Minimatch
- return minimatch.defaults(def).Minimatch
-}
-
-function minimatch (p, pattern, options) {
- if (typeof pattern !== 'string') {
- throw new TypeError('glob pattern string required')
- }
-
- if (!options) options = {}
-
- // shortcut: comments match nothing.
- if (!options.nocomment && pattern.charAt(0) === '#') {
- return false
- }
-
- // "" only matches ""
- if (pattern.trim() === '') return p === ''
-
- return new Minimatch(pattern, options).match(p)
-}
-
-function Minimatch (pattern, options) {
- if (!(this instanceof Minimatch)) {
- return new Minimatch(pattern, options)
- }
-
- if (typeof pattern !== 'string') {
- throw new TypeError('glob pattern string required')
- }
-
- if (!options) options = {}
- pattern = pattern.trim()
-
- // windows support: need to use /, not \
- if (path.sep !== '/') {
- pattern = pattern.split(path.sep).join('/')
- }
-
- this.options = options
- this.set = []
- this.pattern = pattern
- this.regexp = null
- this.negate = false
- this.comment = false
- this.empty = false
-
- // make the set of regexps etc.
- this.make()
-}
-
-Minimatch.prototype.debug = function () {}
-
-Minimatch.prototype.make = make
-function make () {
- // don't do it more than once.
- if (this._made) return
-
- var pattern = this.pattern
- var options = this.options
-
- // empty patterns and comments match nothing.
- if (!options.nocomment && pattern.charAt(0) === '#') {
- this.comment = true
- return
- }
- if (!pattern) {
- this.empty = true
- return
- }
-
- // step 1: figure out negation, etc.
- this.parseNegate()
-
- // step 2: expand braces
- var set = this.globSet = this.braceExpand()
-
- if (options.debug) this.debug = console.error
-
- this.debug(this.pattern, set)
-
- // step 3: now we have a set, so turn each one into a series of path-portion
- // matching patterns.
- // These will be regexps, except in the case of "**", which is
- // set to the GLOBSTAR object for globstar behavior,
- // and will not contain any / characters
- set = this.globParts = set.map(function (s) {
- return s.split(slashSplit)
- })
-
- this.debug(this.pattern, set)
-
- // glob --> regexps
- set = set.map(function (s, si, set) {
- return s.map(this.parse, this)
- }, this)
-
- this.debug(this.pattern, set)
-
- // filter out everything that didn't compile properly.
- set = set.filter(function (s) {
- return s.indexOf(false) === -1
- })
-
- this.debug(this.pattern, set)
-
- this.set = set
-}
-
-Minimatch.prototype.parseNegate = parseNegate
-function parseNegate () {
- var pattern = this.pattern
- var negate = false
- var options = this.options
- var negateOffset = 0
-
- if (options.nonegate) return
-
- for (var i = 0, l = pattern.length
- ; i < l && pattern.charAt(i) === '!'
- ; i++) {
- negate = !negate
- negateOffset++
- }
-
- if (negateOffset) this.pattern = pattern.substr(negateOffset)
- this.negate = negate
-}
-
-// Brace expansion:
-// a{b,c}d -> abd acd
-// a{b,}c -> abc ac
-// a{0..3}d -> a0d a1d a2d a3d
-// a{b,c{d,e}f}g -> abg acdfg acefg
-// a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg
-//
-// Invalid sets are not expanded.
-// a{2..}b -> a{2..}b
-// a{b}c -> a{b}c
-minimatch.braceExpand = function (pattern, options) {
- return braceExpand(pattern, options)
-}
-
-Minimatch.prototype.braceExpand = braceExpand
-
-function braceExpand (pattern, options) {
- if (!options) {
- if (this instanceof Minimatch) {
- options = this.options
- } else {
- options = {}
- }
- }
-
- pattern = typeof pattern === 'undefined'
- ? this.pattern : pattern
-
- if (typeof pattern === 'undefined') {
- throw new TypeError('undefined pattern')
- }
-
- if (options.nobrace ||
- !pattern.match(/\{.*\}/)) {
- // shortcut. no need to expand.
- return [pattern]
- }
-
- return expand(pattern)
-}
-
-// parse a component of the expanded set.
-// At this point, no pattern may contain "/" in it
-// so we're going to return a 2d array, where each entry is the full
-// pattern, split on '/', and then turned into a regular expression.
-// A regexp is made at the end which joins each array with an
-// escaped /, and another full one which joins each regexp with |.
-//
-// Following the lead of Bash 4.1, note that "**" only has special meaning
-// when it is the *only* thing in a path portion. Otherwise, any series
-// of * is equivalent to a single *. Globstar behavior is enabled by
-// default, and can be disabled by setting options.noglobstar.
-Minimatch.prototype.parse = parse
-var SUBPARSE = {}
-function parse (pattern, isSub) {
- if (pattern.length > 1024 * 64) {
- throw new TypeError('pattern is too long')
- }
-
- var options = this.options
-
- // shortcuts
- if (!options.noglobstar && pattern === '**') return GLOBSTAR
- if (pattern === '') return ''
-
- var re = ''
- var hasMagic = !!options.nocase
- var escaping = false
- // ? => one single character
- var patternListStack = []
- var negativeLists = []
- var plType
- var stateChar
- var inClass = false
- var reClassStart = -1
- var classStart = -1
- // . and .. never match anything that doesn't start with .,
- // even when options.dot is set.
- var patternStart = pattern.charAt(0) === '.' ? '' // anything
- // not (start or / followed by . or .. followed by / or end)
- : options.dot ? '(?!(?:^|\\\/)\\.{1,2}(?:$|\\\/))'
- : '(?!\\.)'
- var self = this
-
- function clearStateChar () {
- if (stateChar) {
- // we had some state-tracking character
- // that wasn't consumed by this pass.
- switch (stateChar) {
- case '*':
- re += star
- hasMagic = true
- break
- case '?':
- re += qmark
- hasMagic = true
- break
- default:
- re += '\\' + stateChar
- break
- }
- self.debug('clearStateChar %j %j', stateChar, re)
- stateChar = false
- }
- }
-
- for (var i = 0, len = pattern.length, c
- ; (i < len) && (c = pattern.charAt(i))
- ; i++) {
- this.debug('%s\t%s %s %j', pattern, i, re, c)
-
- // skip over any that are escaped.
- if (escaping && reSpecials[c]) {
- re += '\\' + c
- escaping = false
- continue
- }
-
- switch (c) {
- case '/':
- // completely not allowed, even escaped.
- // Should already be path-split by now.
- return false
-
- case '\\':
- clearStateChar()
- escaping = true
- continue
-
- // the various stateChar values
- // for the "extglob" stuff.
- case '?':
- case '*':
- case '+':
- case '@':
- case '!':
- this.debug('%s\t%s %s %j <-- stateChar', pattern, i, re, c)
-
- // all of those are literals inside a class, except that
- // the glob [!a] means [^a] in regexp
- if (inClass) {
- this.debug(' in class')
- if (c === '!' && i === classStart + 1) c = '^'
- re += c
- continue
- }
-
- // if we already have a stateChar, then it means
- // that there was something like ** or +? in there.
- // Handle the stateChar, then proceed with this one.
- self.debug('call clearStateChar %j', stateChar)
- clearStateChar()
- stateChar = c
- // if extglob is disabled, then +(asdf|foo) isn't a thing.
- // just clear the statechar *now*, rather than even diving into
- // the patternList stuff.
- if (options.noext) clearStateChar()
- continue
-
- case '(':
- if (inClass) {
- re += '('
- continue
- }
-
- if (!stateChar) {
- re += '\\('
- continue
- }
-
- plType = stateChar
- patternListStack.push({
- type: plType,
- start: i - 1,
- reStart: re.length
- })
- // negation is (?:(?!js)[^/]*)
- re += stateChar === '!' ? '(?:(?!(?:' : '(?:'
- this.debug('plType %j %j', stateChar, re)
- stateChar = false
- continue
-
- case ')':
- if (inClass || !patternListStack.length) {
- re += '\\)'
- continue
- }
-
- clearStateChar()
- hasMagic = true
- re += ')'
- var pl = patternListStack.pop()
- plType = pl.type
- // negation is (?:(?!js)[^/]*)
- // The others are (?:<pattern>)<type>
- switch (plType) {
- case '!':
- negativeLists.push(pl)
- re += ')[^/]*?)'
- pl.reEnd = re.length
- break
- case '?':
- case '+':
- case '*':
- re += plType
- break
- case '@': break // the default anyway
- }
- continue
-
- case '|':
- if (inClass || !patternListStack.length || escaping) {
- re += '\\|'
- escaping = false
- continue
- }
-
- clearStateChar()
- re += '|'
- continue
-
- // these are mostly the same in regexp and glob
- case '[':
- // swallow any state-tracking char before the [
- clearStateChar()
-
- if (inClass) {
- re += '\\' + c
- continue
- }
-
- inClass = true
- classStart = i
- reClassStart = re.length
- re += c
- continue
-
- case ']':
- // a right bracket shall lose its special
- // meaning and represent itself in
- // a bracket expression if it occurs
- // first in the list. -- POSIX.2 2.8.3.2
- if (i === classStart + 1 || !inClass) {
- re += '\\' + c
- escaping = false
- continue
- }
-
- // handle the case where we left a class open.
- // "[z-a]" is valid, equivalent to "\[z-a\]"
- if (inClass) {
- // split where the last [ was, make sure we don't have
- // an invalid re. if so, re-walk the contents of the
- // would-be class to re-translate any characters that
- // were passed through as-is
- // TODO: It would probably be faster to determine this
- // without a try/catch and a new RegExp, but it's tricky
- // to do safely. For now, this is safe and works.
- var cs = pattern.substring(classStart + 1, i)
- try {
- RegExp('[' + cs + ']')
- } catch (er) {
- // not a valid class!
- var sp = this.parse(cs, SUBPARSE)
- re = re.substr(0, reClassStart) + '\\[' + sp[0] + '\\]'
- hasMagic = hasMagic || sp[1]
- inClass = false
- continue
- }
- }
-
- // finish up the class.
- hasMagic = true
- inClass = false
- re += c
- continue
-
- default:
- // swallow any state char that wasn't consumed
- clearStateChar()
-
- if (escaping) {
- // no need
- escaping = false
- } else if (reSpecials[c]
- && !(c === '^' && inClass)) {
- re += '\\'
- }
-
- re += c
-
- } // switch
- } // for
-
- // handle the case where we left a class open.
- // "[abc" is valid, equivalent to "\[abc"
- if (inClass) {
- // split where the last [ was, and escape it
- // this is a huge pita. We now have to re-walk
- // the contents of the would-be class to re-translate
- // any characters that were passed through as-is
- cs = pattern.substr(classStart + 1)
- sp = this.parse(cs, SUBPARSE)
- re = re.substr(0, reClassStart) + '\\[' + sp[0]
- hasMagic = hasMagic || sp[1]
- }
-
- // handle the case where we had a +( thing at the *end*
- // of the pattern.
- // each pattern list stack adds 3 chars, and we need to go through
- // and escape any | chars that were passed through as-is for the regexp.
- // Go through and escape them, taking care not to double-escape any
- // | chars that were already escaped.
- for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) {
- var tail = re.slice(pl.reStart + 3)
- // maybe some even number of \, then maybe 1 \, followed by a |
- tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, function (_, $1, $2) {
- if (!$2) {
- // the | isn't already escaped, so escape it.
- $2 = '\\'
- }
-
- // need to escape all those slashes *again*, without escaping the
- // one that we need for escaping the | character. As it works out,
- // escaping an even number of slashes can be done by simply repeating
- // it exactly after itself. That's why this trick works.
- //
- // I am sorry that you have to see this.
- return $1 + $1 + $2 + '|'
- })
-
- this.debug('tail=%j\n %s', tail, tail)
- var t = pl.type === '*' ? star
- : pl.type === '?' ? qmark
- : '\\' + pl.type
-
- hasMagic = true
- re = re.slice(0, pl.reStart) + t + '\\(' + tail
- }
-
- // handle trailing things that only matter at the very end.
- clearStateChar()
- if (escaping) {
- // trailing \\
- re += '\\\\'
- }
-
- // only need to apply the nodot start if the re starts with
- // something that could conceivably capture a dot
- var addPatternStart = false
- switch (re.charAt(0)) {
- case '.':
- case '[':
- case '(': addPatternStart = true
- }
-
- // Hack to work around lack of negative lookbehind in JS
- // A pattern like: *.!(x).!(y|z) needs to ensure that a name
- // like 'a.xyz.yz' doesn't match. So, the first negative
- // lookahead, has to look ALL the way ahead, to the end of
- // the pattern.
- for (var n = negativeLists.length - 1; n > -1; n--) {
- var nl = negativeLists[n]
-
- var nlBefore = re.slice(0, nl.reStart)
- var nlFirst = re.slice(nl.reStart, nl.reEnd - 8)
- var nlLast = re.slice(nl.reEnd - 8, nl.reEnd)
- var nlAfter = re.slice(nl.reEnd)
-
- nlLast += nlAfter
-
- // Handle nested stuff like *(*.js|!(*.json)), where open parens
- // mean that we should *not* include the ) in the bit that is considered
- // "after" the negated section.
- var openParensBefore = nlBefore.split('(').length - 1
- var cleanAfter = nlAfter
- for (i = 0; i < openParensBefore; i++) {
- cleanAfter = cleanAfter.replace(/\)[+*?]?/, '')
- }
- nlAfter = cleanAfter
-
- var dollar = ''
- if (nlAfter === '' && isSub !== SUBPARSE) {
- dollar = '$'
- }
- var newRe = nlBefore + nlFirst + nlAfter + dollar + nlLast
- re = newRe
- }
-
- // if the re is not "" at this point, then we need to make sure
- // it doesn't match against an empty path part.
- // Otherwise a/* will match a/, which it should not.
- if (re !== '' && hasMagic) {
- re = '(?=.)' + re
- }
-
- if (addPatternStart) {
- re = patternStart + re
- }
-
- // parsing just a piece of a larger pattern.
- if (isSub === SUBPARSE) {
- return [re, hasMagic]
- }
-
- // skip the regexp for non-magical patterns
- // unescape anything in it, though, so that it'll be
- // an exact match against a file etc.
- if (!hasMagic) {
- return globUnescape(pattern)
- }
-
- var flags = options.nocase ? 'i' : ''
- try {
- var regExp = new RegExp('^' + re + '$', flags)
- } catch (er) {
- // If it was an invalid regular expression, then it can't match
- // anything. This trick looks for a character after the end of
- // the string, which is of course impossible, except in multi-line
- // mode, but it's not a /m regex.
- return new RegExp('$.')
- }
-
- regExp._glob = pattern
- regExp._src = re
-
- return regExp
-}
-
-minimatch.makeRe = function (pattern, options) {
- return new Minimatch(pattern, options || {}).makeRe()
-}
-
-Minimatch.prototype.makeRe = makeRe
-function makeRe () {
- if (this.regexp || this.regexp === false) return this.regexp
-
- // at this point, this.set is a 2d array of partial
- // pattern strings, or "**".
- //
- // It's better to use .match(). This function shouldn't
- // be used, really, but it's pretty convenient sometimes,
- // when you just want to work with a regex.
- var set = this.set
-
- if (!set.length) {
- this.regexp = false
- return this.regexp
- }
- var options = this.options
-
- var twoStar = options.noglobstar ? star
- : options.dot ? twoStarDot
- : twoStarNoDot
- var flags = options.nocase ? 'i' : ''
-
- var re = set.map(function (pattern) {
- return pattern.map(function (p) {
- return (p === GLOBSTAR) ? twoStar
- : (typeof p === 'string') ? regExpEscape(p)
- : p._src
- }).join('\\\/')
- }).join('|')
-
- // must match entire pattern
- // ending in a * or ** will make it less strict.
- re = '^(?:' + re + ')$'
-
- // can match anything, as long as it's not this.
- if (this.negate) re = '^(?!' + re + ').*$'
-
- try {
- this.regexp = new RegExp(re, flags)
- } catch (ex) {
- this.regexp = false
- }
- return this.regexp
-}
-
-minimatch.match = function (list, pattern, options) {
- options = options || {}
- var mm = new Minimatch(pattern, options)
- list = list.filter(function (f) {
- return mm.match(f)
- })
- if (mm.options.nonull && !list.length) {
- list.push(pattern)
- }
- return list
-}
-
-Minimatch.prototype.match = match
-function match (f, partial) {
- this.debug('match', f, this.pattern)
- // short-circuit in the case of busted things.
- // comments, etc.
- if (this.comment) return false
- if (this.empty) return f === ''
-
- if (f === '/' && partial) return true
-
- var options = this.options
-
- // windows: need to use /, not \
- if (path.sep !== '/') {
- f = f.split(path.sep).join('/')
- }
-
- // treat the test path as a set of pathparts.
- f = f.split(slashSplit)
- this.debug(this.pattern, 'split', f)
-
- // just ONE of the pattern sets in this.set needs to match
- // in order for it to be valid. If negating, then just one
- // match means that we have failed.
- // Either way, return on the first hit.
-
- var set = this.set
- this.debug(this.pattern, 'set', set)
-
- // Find the basename of the path by looking for the last non-empty segment
- var filename
- var i
- for (i = f.length - 1; i >= 0; i--) {
- filename = f[i]
- if (filename) break
- }
-
- for (i = 0; i < set.length; i++) {
- var pattern = set[i]
- var file = f
- if (options.matchBase && pattern.length === 1) {
- file = [filename]
- }
- var hit = this.matchOne(file, pattern, partial)
- if (hit) {
- if (options.flipNegate) return true
- return !this.negate
- }
- }
-
- // didn't get any hits. this is success if it's a negative
- // pattern, failure otherwise.
- if (options.flipNegate) return false
- return this.negate
-}
-
-// set partial to true to test if, for example,
-// "/a/b" matches the start of "/*/b/*/d"
-// Partial means, if you run out of file before you run
-// out of pattern, then that's fine, as long as all
-// the parts match.
-Minimatch.prototype.matchOne = function (file, pattern, partial) {
- var options = this.options
-
- this.debug('matchOne',
- { 'this': this, file: file, pattern: pattern })
-
- this.debug('matchOne', file.length, pattern.length)
-
- for (var fi = 0,
- pi = 0,
- fl = file.length,
- pl = pattern.length
- ; (fi < fl) && (pi < pl)
- ; fi++, pi++) {
- this.debug('matchOne loop')
- var p = pattern[pi]
- var f = file[fi]
-
- this.debug(pattern, p, f)
-
- // should be impossible.
- // some invalid regexp stuff in the set.
- if (p === false) return false
-
- if (p === GLOBSTAR) {
- this.debug('GLOBSTAR', [pattern, p, f])
-
- // "**"
- // a/**/b/**/c would match the following:
- // a/b/x/y/z/c
- // a/x/y/z/b/c
- // a/b/x/b/x/c
- // a/b/c
- // To do this, take the rest of the pattern after
- // the **, and see if it would match the file remainder.
- // If so, return success.
- // If not, the ** "swallows" a segment, and try again.
- // This is recursively awful.
- //
- // a/**/b/**/c matching a/b/x/y/z/c
- // - a matches a
- // - doublestar
- // - matchOne(b/x/y/z/c, b/**/c)
- // - b matches b
- // - doublestar
- // - matchOne(x/y/z/c, c) -> no
- // - matchOne(y/z/c, c) -> no
- // - matchOne(z/c, c) -> no
- // - matchOne(c, c) yes, hit
- var fr = fi
- var pr = pi + 1
- if (pr === pl) {
- this.debug('** at the end')
- // a ** at the end will just swallow the rest.
- // We have found a match.
- // however, it will not swallow /.x, unless
- // options.dot is set.
- // . and .. are *never* matched by **, for explosively
- // exponential reasons.
- for (; fi < fl; fi++) {
- if (file[fi] === '.' || file[fi] === '..' ||
- (!options.dot && file[fi].charAt(0) === '.')) return false
- }
- return true
- }
-
- // ok, let's see if we can swallow whatever we can.
- while (fr < fl) {
- var swallowee = file[fr]
-
- this.debug('\nglobstar while', file, fr, pattern, pr, swallowee)
-
- // XXX remove this slice. Just pass the start index.
- if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
- this.debug('globstar found match!', fr, fl, swallowee)
- // found a match.
- return true
- } else {
- // can't swallow "." or ".." ever.
- // can only swallow ".foo" when explicitly asked.
- if (swallowee === '.' || swallowee === '..' ||
- (!options.dot && swallowee.charAt(0) === '.')) {
- this.debug('dot detected!', file, fr, pattern, pr)
- break
- }
-
- // ** swallows a segment, and continue.
- this.debug('globstar swallow a segment, and continue')
- fr++
- }
- }
-
- // no match was found.
- // However, in partial mode, we can't say this is necessarily over.
- // If there's more *pattern* left, then
- if (partial) {
- // ran out of file
- this.debug('\n>>> no match, partial?', file, fr, pattern, pr)
- if (fr === fl) return true
- }
- return false
- }
-
- // something other than **
- // non-magic patterns just have to match exactly
- // patterns with magic have been turned into regexps.
- var hit
- if (typeof p === 'string') {
- if (options.nocase) {
- hit = f.toLowerCase() === p.toLowerCase()
- } else {
- hit = f === p
- }
- this.debug('string match', p, f, hit)
- } else {
- hit = f.match(p)
- this.debug('pattern match', p, f, hit)
- }
-
- if (!hit) return false
- }
-
- // Note: ending in / means that we'll get a final ""
- // at the end of the pattern. This can only match a
- // corresponding "" at the end of the file.
- // If the file ends in /, then it can only match a
- // a pattern that ends in /, unless the pattern just
- // doesn't have any more for it. But, a/b/ should *not*
- // match "a/b/*", even though "" matches against the
- // [^/]*? pattern, except in partial mode, where it might
- // simply not be reached yet.
- // However, a/b/ should still satisfy a/*
-
- // now either we fell off the end of the pattern, or we're done.
- if (fi === fl && pi === pl) {
- // ran out of pattern and filename at the same time.
- // an exact hit!
- return true
- } else if (fi === fl) {
- // ran out of file, but still had pattern left.
- // this is ok if we're doing the match as part of
- // a glob fs traversal.
- return partial
- } else if (pi === pl) {
- // ran out of pattern, still have file left.
- // this is only acceptable if we're on the very last
- // empty segment of a file with a trailing slash.
- // a/* should match a/b/
- var emptyFileEnd = (fi === fl - 1) && (file[fi] === '')
- return emptyFileEnd
- }
-
- // should be unreachable.
- throw new Error('wtf?')
-}
-
-// replace stuff like \* with *
-function globUnescape (s) {
- return s.replace(/\\(.)/g, '$1')
-}
-
-function regExpEscape (s) {
- return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&')
-}
http://git-wip-us.apache.org/repos/asf/cordova-create/blob/9fb2883e/node_modules/cordova-fetch/node_modules/minimatch/package.json
----------------------------------------------------------------------
diff --git a/node_modules/cordova-fetch/node_modules/minimatch/package.json b/node_modules/cordova-fetch/node_modules/minimatch/package.json
deleted file mode 100644
index 6ff1900..0000000
--- a/node_modules/cordova-fetch/node_modules/minimatch/package.json
+++ /dev/null
@@ -1,107 +0,0 @@
-{
- "_args": [
- [
- {
- "name": "minimatch",
- "raw": "minimatch@^3.0.0",
- "rawSpec": "^3.0.0",
- "scope": null,
- "spec": ">=3.0.0 <4.0.0",
- "type": "range"
- },
- "/Users/ctran/cordova/cordova-lib/cordova-create/node_modules/cordova-common"
- ],
- [
- {
- "name": "minimatch",
- "raw": "minimatch@^3.0.2",
- "rawSpec": "^3.0.2",
- "scope": null,
- "spec": ">=3.0.2 <4.0.0",
- "type": "range"
- },
- "/Users/ctran/cordova/cordova-lib/cordova-create/node_modules/cordova-fetch/node_modules/glob"
- ]
- ],
- "_from": "minimatch@^3.0.2",
- "_id": "minimatch@3.0.2",
- "_inCache": true,
- "_installable": true,
- "_location": "/cordova-fetch/minimatch",
- "_nodeVersion": "4.4.4",
- "_npmOperationalInternal": {
- "host": "packages-16-east.internal.npmjs.com",
- "tmp": "tmp/minimatch-3.0.2.tgz_1466194379770_0.11417287751100957"
- },
- "_npmUser": {
- "email": "i@izs.me",
- "name": "isaacs"
- },
- "_npmVersion": "3.9.1",
- "_phantomChildren": {},
- "_requested": {
- "name": "minimatch",
- "raw": "minimatch@^3.0.2",
- "rawSpec": "^3.0.2",
- "scope": null,
- "spec": ">=3.0.2 <4.0.0",
- "type": "range"
- },
- "_requiredBy": [
- "/cordova-fetch/glob"
- ],
- "_resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.2.tgz",
- "_shasum": "0f398a7300ea441e9c348c83d98ab8c9dbf9c40a",
- "_shrinkwrap": null,
- "_spec": "minimatch@^3.0.2",
- "_where": "/Users/ctran/cordova/cordova-lib/cordova-create/node_modules/cordova-fetch/node_modules/glob",
- "author": {
- "email": "i@izs.me",
- "name": "Isaac Z. Schlueter",
- "url": "http://blog.izs.me"
- },
- "bugs": {
- "url": "https://github.com/isaacs/minimatch/issues"
- },
- "dependencies": {
- "brace-expansion": "^1.0.0"
- },
- "description": "a glob matcher in javascript",
- "devDependencies": {
- "standard": "^3.7.2",
- "tap": "^5.6.0"
- },
- "directories": {},
- "dist": {
- "shasum": "0f398a7300ea441e9c348c83d98ab8c9dbf9c40a",
- "tarball": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.2.tgz"
- },
- "engines": {
- "node": "*"
- },
- "files": [
- "minimatch.js"
- ],
- "gitHead": "81edb7c763abd31ba981c87ec5e835f178786be0",
- "homepage": "https://github.com/isaacs/minimatch#readme",
- "license": "ISC",
- "main": "minimatch.js",
- "maintainers": [
- {
- "email": "i@izs.me",
- "name": "isaacs"
- }
- ],
- "name": "minimatch",
- "optionalDependencies": {},
- "readme": "ERROR: No README data found!",
- "repository": {
- "type": "git",
- "url": "git://github.com/isaacs/minimatch.git"
- },
- "scripts": {
- "posttest": "standard minimatch.js test/*.js",
- "test": "tap test/*.js"
- },
- "version": "3.0.2"
-}
http://git-wip-us.apache.org/repos/asf/cordova-create/blob/9fb2883e/node_modules/cordova-fetch/node_modules/q/CHANGES.md
----------------------------------------------------------------------
diff --git a/node_modules/cordova-fetch/node_modules/q/CHANGES.md b/node_modules/cordova-fetch/node_modules/q/CHANGES.md
deleted file mode 100644
index cd351fd..0000000
--- a/node_modules/cordova-fetch/node_modules/q/CHANGES.md
+++ /dev/null
@@ -1,786 +0,0 @@
-
-## 1.4.1
-
- - Address an issue that prevented Q from being used as a `<script>` for
- Firefox add-ons. Q can now be used in any environment that provides `window`
- or `self` globals, favoring `window` since add-ons have an an immutable
- `self` that is distinct from `window`.
-
-## 1.4.0
-
- - Add `noConflict` support for use in `<script>` (@jahnjw).
-
-## 1.3.0
-
- - Add tracking for unhandled and handled rejections in Node.js (@benjamingr).
-
-## 1.2.1
-
- - Fix Node.js environment detection for modern Browserify (@kahnjw).
-
-## 1.2.0
-
- - Added Q.any(promisesArray) method (@vergara).
- Returns a promise fulfilled with the value of the first resolved promise in
- promisesArray. If all promises in promisesArray are rejected, it returns
- a rejected promise.
-
-## 1.1.2
-
- - Removed extraneous files from the npm package by using the "files"
- whitelist in package.json instead of the .npmignore blacklist.
- (@anton-rudeshko)
-
-## 1.1.1
-
- - Fix a pair of regressions in bootstrapping, one which precluded
- WebWorker support, and another that precluded support in
- ``<script>`` usage outright. #607
-
-## 1.1.0
-
- - Adds support for enabling long stack traces in node.js by setting
- environment variable `Q_DEBUG=1`.
- - Introduces the `tap` method to promises, which will see a value
- pass through without alteration.
- - Use instanceof to recognize own promise instances as opposed to
- thenables.
- - Construct timeout errors with `code === ETIMEDOUT` (Kornel Lesi\u0144ski)
- - More descriminant CommonJS module environment detection.
- - Dropped continuous integration for Node.js 0.6 and 0.8 because of
- changes to npm that preclude the use of new `^` version predicate
- operator in any transitive dependency.
- - Users can now override `Q.nextTick`.
-
-## 1.0.1
-
- - Adds support for `Q.Promise`, which implements common usage of the
- ES6 `Promise` constructor and its methods. `Promise` does not have
- a valid promise constructor and a proper implementation awaits
- version 2 of Q.
- - Removes the console stopgap for a promise inspector. This no longer
- works with any degree of reliability.
- - Fixes support for content security policies that forbid eval. Now
- using the `StopIteration` global to distinguish SpiderMonkey
- generators from ES6 generators, assuming that they will never
- coexist.
-
-## 1.0.0
-
-:cake: This is all but a re-release of version 0.9, which has settled
-into a gentle maintenance mode and rightly deserves an official 1.0.
-An ambitious 2.0 release is already around the corner, but 0.9/1.0
-have been distributed far and wide and demand long term support.
-
- - Q will now attempt to post a debug message in browsers regardless
- of whether window.Touch is defined. Chrome at least now has this
- property regardless of whether touch is supported by the underlying
- hardware.
- - Remove deprecation warning from `promise.valueOf`. The function is
- called by the browser in various ways so there is no way to
- distinguish usage that should be migrated from usage that cannot be
- altered.
-
-## 0.9.7
-
- - :warning: `q.min.js` is no longer checked-in. It is however still
- created by Grunt and NPM.
- - Fixes a bug that inhibited `Q.async` with implementations of the new
- ES6 generators.
- - Fixes a bug with `nextTick` affecting Safari 6.0.5 the first time a
- page loads when an `iframe` is involved.
- - Introduces `passByCopy`, `join`, and `race`.
- - Shows stack traces or error messages on the console, instead of
- `Error` objects.
- - Elimintates wrapper methods for improved performance.
- - `Q.all` now propagates progress notifications of the form you might
- expect of ES6 iterations, `{value, index}` where the `value` is the
- progress notification from the promise at `index`.
-
-## 0.9.6
-
- - Fixes a bug in recognizing the difference between compatible Q
- promises, and Q promises from before the implementation of "inspect".
- The latter are now coerced.
- - Fixes an infinite asynchronous coercion cycle introduced by former
- solution, in two independently sufficient ways. 1.) All promises
- returned by makePromise now implement "inspect", albeit a default
- that reports that the promise has an "unknown" state. 2.) The
- implementation of "then/when" is now in "then" instead of "when", so
- that the responsibility to "coerce" the given promise rests solely in
- the "when" method and the "then" method may assume that "this" is a
- promise of the right type.
- - Refactors `nextTick` to use an unrolled microtask within Q regardless
- of how new ticks a requested. #316 @rkatic
-
-## 0.9.5
-
- - Introduces `inspect` for getting the state of a promise as
- `{state: "fulfilled" | "rejected" | "pending", value | reason}`.
- - Introduces `allSettled` which produces an array of promises states
- for the input promises once they have all "settled". This is in
- accordance with a discussion on Promises/A+ that "settled" refers to
- a promise that is "fulfilled" or "rejected". "resolved" refers to a
- deferred promise that has been "resolved" to another promise,
- "sealing its fate" to the fate of the successor promise.
- - Long stack traces are now off by default. Set `Q.longStackSupport`
- to true to enable long stack traces.
- - Long stack traces can now follow the entire asynchronous history of a
- promise, not just a single jump.
- - Introduces `spawn` for an immediately invoked asychronous generator.
- @jlongster
- - Support for *experimental* synonyms `mapply`, `mcall`, `nmapply`,
- `nmcall` for method invocation.
-
-## 0.9.4
-
- - `isPromise` and `isPromiseAlike` now always returns a boolean
- (even for falsy values). #284 @lfac-pt
- - Support for ES6 Generators in `async` #288 @andywingo
- - Clear duplicate promise rejections from dispatch methods #238 @SLaks
- - Unhandled rejection API #296 @domenic
- `stopUnhandledRejectionTracking`, `getUnhandledReasons`,
- `resetUnhandledRejections`.
-
-## 0.9.3
-
- - Add the ability to give `Q.timeout`'s errors a custom error message. #270
- @jgrenon
- - Fix Q's call-stack busting behavior in Node.js 0.10, by switching from
- `process.nextTick` to `setImmediate`. #254 #259
- - Fix Q's behavior when used with the Mocha test runner in the browser, since
- Mocha introduces a fake `process` global without a `nextTick` property. #267
- - Fix some, but not all, cases wherein Q would give false positives in its
- unhandled rejection detection (#252). A fix for other cases (#238) is
- hopefully coming soon.
- - Made `Q.promise` throw early if given a non-function.
-
-## 0.9.2
-
- - Pass through progress notifications when using `timeout`. #229 @omares
- - Pass through progress notifications when using `delay`.
- - Fix `nbind` to actually bind the `thisArg`. #232 @davidpadbury
-
-## 0.9.1
-
- - Made the AMD detection compatible with the RequireJS optimizer's `namespace`
- option. #225 @terinjokes
- - Fix side effects from `valueOf`, and thus from `isFulfilled`, `isRejected`,
- and `isPending`. #226 @benjamn
-
-## 0.9.0
-
-This release removes many layers of deprecated methods and brings Q closer to
-alignment with Mark Miller\u2019s TC39 [strawman][] for concurrency. At the same
-time, it fixes many bugs and adds a few features around error handling. Finally,
-it comes with an updated and comprehensive [API Reference][].
-
-[strawman]: http://wiki.ecmascript.org/doku.php?id=strawman:concurrency
-[API Reference]: https://github.com/kriskowal/q/wiki/API-Reference
-
-### API Cleanup
-
-The following deprecated or undocumented methods have been removed.
-Their replacements are listed here:
-
-<table>
- <thead>
- <tr>
- <th>0.8.x method</th>
- <th>0.9 replacement</th>
- </tr>
- </thead>
- <tbody>
- <tr>
- <td><code>Q.ref</code></td>
- <td><code>Q</code></td>
- </tr>
- <tr>
- <td><code>call</code>, <code>apply</code>, <code>bind</code> (*)</td>
- <td><code>fcall</code>/<code>invoke</code>, <code>fapply</code>/<code>post</code>, <code>fbind</code></td>
- </tr>
- <tr>
- <td><code>ncall</code>, <code>napply</code> (*)</td>
- <td><code>nfcall</code>/<code>ninvoke</code>, <code>nfapply</code>/<code>npost</code></td>
- </tr>
- <tr>
- <td><code>end</code></td>
- <td><code>done</code></td>
- </tr>
- <tr>
- <td><code>put</code></td>
- <td><code>set</code></td>
- </tr>
- <tr>
- <td><code>node</code></td>
- <td><code>nbind</code></td>
- </tr>
- <tr>
- <td><code>nend</code></td>
- <td><code>nodeify</code></td>
- </tr>
- <tr>
- <td><code>isResolved</code></td>
- <td><code>isPending</code></td>
- </tr>
- <tr>
- <td><code>deferred.node</code></td>
- <td><code>deferred.makeNodeResolver</code></td>
- </tr>
- <tr>
- <td><code>Method</code>, <code>sender</code></td>
- <td><code>dispatcher</code></td>
- </tr>
- <tr>
- <td><code>send</code></td>
- <td><code>dispatch</code></td>
- </tr>
- <tr>
- <td><code>view</code>, <code>viewInfo</code></td>
- <td>(none)</td>
- </tr>
- </tbody>
-</table>
-
-
-(*) Use of ``thisp`` is discouraged. For calling methods, use ``post`` or
-``invoke``.
-
-### Alignment with the Concurrency Strawman
-
-- Q now exports a `Q(value)` function, an alias for `resolve`.
- `Q.call`, `Q.apply`, and `Q.bind` were removed to make room for the
- same methods on the function prototype.
-- `invoke` has been aliased to `send` in all its forms.
-- `post` with no method name acts like `fapply`.
-
-### Error Handling
-
-- Long stack traces can be turned off by setting `Q.stackJumpLimit` to zero.
- In the future, this property will be used to fine tune how many stack jumps
- are retained in long stack traces; for now, anything nonzero is treated as
- one (since Q only tracks one stack jump at the moment, see #144). #168
-- In Node.js, if there are unhandled rejections when the process exits, they
- are output to the console. #115
-
-### Other
-
-- `delete` and `set` (n�e `put`) no longer have a fulfillment value.
-- Q promises are no longer frozen, which
- [helps with performance](http://code.google.com/p/v8/issues/detail?id=1858).
-- `thenReject` is now included, as a counterpart to `thenResolve`.
-- The included browser `nextTick` shim is now faster. #195 @rkatic.
-
-### Bug Fixes
-
-- Q now works in Internet Explorer 10. #186 @ForbesLindesay
-- `fbind` no longer hard-binds the returned function's `this` to `undefined`.
- #202
-- `Q.reject` no longer leaks memory. #148
-- `npost` with no arguments now works. #207
-- `allResolved` now works with non-Q promises ("thenables"). #179
-- `keys` behavior is now correct even in browsers without native
- `Object.keys`. #192 @rkatic
-- `isRejected` and the `exception` property now work correctly if the
- rejection reason is falsy. #198
-
-### Internals and Advanced
-
-- The internal interface for a promise now uses
- `dispatchPromise(resolve, op, operands)` instead of `sendPromise(op,
- resolve, ...operands)`, which reduces the cases where Q needs to do
- argument slicing.
-- The internal protocol uses different operands. "put" is now "set".
- "del" is now "delete". "view" and "viewInfo" have been removed.
-- `Q.fulfill` has been added. It is distinct from `Q.resolve` in that
- it does not pass promises through, nor coerces promises from other
- systems. The promise becomes the fulfillment value. This is only
- recommended for use when trying to fulfill a promise with an object that has
- a `then` function that is at the same time not a promise.
-
-## 0.8.12
-- Treat foreign promises as unresolved in `Q.isFulfilled`; this lets `Q.all`
- work on arrays containing foreign promises. #154
-- Fix minor incompliances with the [Promises/A+ spec][] and [test suite][]. #157
- #158
-
-[Promises/A+ spec]: http://promises-aplus.github.com/promises-spec/
-[test suite]: https://github.com/promises-aplus/promises-tests
-
-## 0.8.11
-
- - Added ``nfcall``, ``nfapply``, and ``nfbind`` as ``thisp``-less versions of
- ``ncall``, ``napply``, and ``nbind``. The latter are now deprecated. #142
- - Long stack traces no longer cause linearly-growing memory usage when chaining
- promises together. #111
- - Inspecting ``error.stack`` in a rejection handler will now give a long stack
- trace. #103
- - Fixed ``Q.timeout`` to clear its timeout handle when the promise is rejected;
- previously, it kept the event loop alive until the timeout period expired.
- #145 @dfilatov
- - Added `q/queue` module, which exports an infinite promise queue
- constructor.
-
-## 0.8.10
-
- - Added ``done`` as a replacement for ``end``, taking the usual fulfillment,
- rejection, and progress handlers. It's essentially equivalent to
- ``then(f, r, p).end()``.
- - Added ``Q.onerror``, a settable error trap that you can use to get full stack
- traces for uncaught errors. #94
- - Added ``thenResolve`` as a shortcut for returning a constant value once a
- promise is fulfilled. #108 @ForbesLindesay
- - Various tweaks to progress notification, including propagation and
- transformation of progress values and only forwarding a single progress
- object.
- - Renamed ``nend`` to ``nodeify``. It no longer returns an always-fulfilled
- promise when a Node callback is passed.
- - ``deferred.resolve`` and ``deferred.reject`` no longer (sometimes) return
- ``deferred.promise``.
- - Fixed stack traces getting mangled if they hit ``end`` twice. #116 #121 @ef4
- - Fixed ``ninvoke`` and ``npost`` to work on promises for objects with Node
- methods. #134
- - Fixed accidental coercion of objects with nontrivial ``valueOf`` methods,
- like ``Date``s, by the promise's ``valueOf`` method. #135
- - Fixed ``spread`` not calling the passed rejection handler if given a rejected
- promise.
-
-## 0.8.9
-
- - Added ``nend``
- - Added preliminary progress notification support, via
- ``promise.then(onFulfilled, onRejected, onProgress)``,
- ``promise.progress(onProgress)``, and ``deferred.notify(...progressData)``.
- - Made ``put`` and ``del`` return the object acted upon for easier chaining.
- #84
- - Fixed coercion cycles with cooperating promises. #106
-
-## 0.8.7
-
- - Support [Montage Require](http://github.com/kriskowal/mr)
-
-## 0.8.6
-
- - Fixed ``npost`` and ``ninvoke`` to pass the correct ``thisp``. #74
- - Fixed various cases involving unorthodox rejection reasons. #73 #90
- @ef4
- - Fixed double-resolving of misbehaved custom promises. #75
- - Sped up ``Q.all`` for arrays contain already-resolved promises or scalar
- values. @ForbesLindesay
- - Made stack trace filtering work when concatenating assets. #93 @ef4
- - Added warnings for deprecated methods. @ForbesLindesay
- - Added ``.npmignore`` file so that dependent packages get a slimmer
- ``node_modules`` directory.
-
-## 0.8.5
-
- - Added preliminary support for long traces (@domenic)
- - Added ``fapply``, ``fcall``, ``fbind`` for non-thisp
- promised function calls.
- - Added ``return`` for async generators, where generators
- are implemented.
- - Rejected promises now have an "exception" property. If an object
- isRejected(object), then object.valueOf().exception will
- be the wrapped error.
- - Added Jasmine specifications
- - Support Internet Explorers 7\u20139 (with multiple bug fixes @domenic)
- - Support Firefox 12
- - Support Safari 5.1.5
- - Support Chrome 18
-
-## 0.8.4
-
- - WARNING: ``promise.timeout`` is now rejected with an ``Error`` object
- and the message now includes the duration of the timeout in
- miliseconds. This doesn't constitute (in my opinion) a
- backward-incompatibility since it is a change of an undocumented and
- unspecified public behavior, but if you happened to depend on the
- exception being a string, you will need to revise your code.
- - Added ``deferred.makeNodeResolver()`` to replace the more cryptic
- ``deferred.node()`` method.
- - Added experimental ``Q.promise(maker(resolve, reject))`` to make a
- promise inside a callback, such that thrown exceptions in the
- callback are converted and the resolver and rejecter are arguments.
- This is a shorthand for making a deferred directly and inspired by
- @gozala\u2019s stream constructor pattern and the Microsoft Windows Metro
- Promise constructor interface.
- - Added experimental ``Q.begin()`` that is intended to kick off chains
- of ``.then`` so that each of these can be reordered without having to
- edit the new and former first step.
-
-## 0.8.3
-
- - Added ``isFulfilled``, ``isRejected``, and ``isResolved``
- to the promise prototype.
- - Added ``allResolved`` for waiting for every promise to either be
- fulfilled or rejected, without propagating an error. @utvara #53
- - Added ``Q.bind`` as a method to transform functions that
- return and throw into promise-returning functions. See
- [an example](https://gist.github.com/1782808). @domenic
- - Renamed ``node`` export to ``nbind``, and added ``napply`` to
- complete the set. ``node`` remains as deprecated. @domenic #58
- - Renamed ``Method`` export to ``sender``. ``Method``
- remains as deprecated and will be removed in the next
- major version since I expect it has very little usage.
- - Added browser console message indicating a live list of
- unhandled errors.
- - Added support for ``msSetImmediate`` (IE10) or ``setImmediate``
- (available via [polyfill](https://github.com/NobleJS/setImmediate))
- as a browser-side ``nextTick`` implementation. #44 #50 #59
- - Stopped using the event-queue dependency, which was in place for
- Narwhal support: now directly using ``process.nextTick``.
- - WARNING: EXPERIMENTAL: added ``finally`` alias for ``fin``, ``catch``
- alias for ``fail``, ``try`` alias for ``call``, and ``delete`` alias
- for ``del``. These properties are enquoted in the library for
- cross-browser compatibility, but may be used as property names in
- modern engines.
-
-## 0.8.2
-
- - Deprecated ``ref`` in favor of ``resolve`` as recommended by
- @domenic.
- - Update event-queue dependency.
-
-## 0.8.1
-
- - Fixed Opera bug. #35 @cadorn
- - Fixed ``Q.all([])`` #32 @domenic
-
-## 0.8.0
-
- - WARNING: ``enqueue`` removed. Use ``nextTick`` instead.
- This is more consistent with NodeJS and (subjectively)
- more explicit and intuitive.
- - WARNING: ``def`` removed. Use ``master`` instead. The
- term ``def`` was too confusing to new users.
- - WARNING: ``spy`` removed in favor of ``fin``.
- - WARNING: ``wait`` removed. Do ``all(args).get(0)`` instead.
- - WARNING: ``join`` removed. Do ``all(args).spread(callback)`` instead.
- - WARNING: Removed the ``Q`` function module.exports alias
- for ``Q.ref``. It conflicts with ``Q.apply`` in weird
- ways, making it uncallable.
- - Revised ``delay`` so that it accepts both ``(value,
- timeout)`` and ``(timeout)`` variations based on
- arguments length.
- - Added ``ref().spread(cb(...args))``, a variant of
- ``then`` that spreads an array across multiple arguments.
- Useful with ``all()``.
- - Added ``defer().node()`` Node callback generator. The
- callback accepts ``(error, value)`` or ``(error,
- ...values)``. For multiple value arguments, the
- fulfillment value is an array, useful in conjunction with
- ``spread``.
- - Added ``node`` and ``ncall``, both with the signature
- ``(fun, thisp_opt, ...args)``. The former is a decorator
- and the latter calls immediately. ``node`` optional
- binds and partially applies. ``ncall`` can bind and pass
- arguments.
-
-## 0.7.2
-
- - Fixed thenable promise assimilation.
-
-## 0.7.1
-
- - Stopped shimming ``Array.prototype.reduce``. The
- enumerable property has bad side-effects. Libraries that
- depend on this (for example, QQ) will need to be revised.
-
-## 0.7.0 - BACKWARD INCOMPATIBILITY
-
- - WARNING: Removed ``report`` and ``asap``
- - WARNING: The ``callback`` argument of the ``fin``
- function no longer receives any arguments. Thus, it can
- be used to call functions that should not receive
- arguments on resolution. Use ``when``, ``then``, or
- ``fail`` if you need a value.
- - IMPORTANT: Fixed a bug in the use of ``MessageChannel``
- for ``nextTick``.
- - Renamed ``enqueue`` to ``nextTick``.
- - Added experimental ``view`` and ``viewInfo`` for creating
- views of promises either when or before they're
- fulfilled.
- - Shims are now externally applied so subsequent scripts or
- dependees can use them.
- - Improved minification results.
- - Improved readability.
-
-## 0.6.0 - BACKWARD INCOMPATIBILITY
-
- - WARNING: In practice, the implementation of ``spy`` and
- the name ``fin`` were useful. I've removed the old
- ``fin`` implementation and renamed/aliased ``spy``.
- - The "q" module now exports its ``ref`` function as a "Q"
- constructor, with module systems that support exports
- assignment including NodeJS, RequireJS, and when used as
- a ``<script>`` tag. Notably, strictly compliant CommonJS
- does not support this, but UncommonJS does.
- - Added ``async`` decorator for generators that use yield
- to "trampoline" promises. In engines that support
- generators (SpiderMonkey), this will greatly reduce the
- need for nested callbacks.
- - Made ``when`` chainable.
- - Made ``all`` chainable.
-
-## 0.5.3
-
- - Added ``all`` and refactored ``join`` and ``wait`` to use
- it. All of these will now reject at the earliest
- rejection.
-
-## 0.5.2
-
- - Minor improvement to ``spy``; now waits for resolution of
- callback promise.
-
-## 0.5.1
-
- - Made most Q API methods chainable on promise objects, and
- turned the previous promise-methods of ``join``,
- ``wait``, and ``report`` into Q API methods.
- - Added ``apply`` and ``call`` to the Q API, and ``apply``
- as a promise handler.
- - Added ``fail``, ``fin``, and ``spy`` to Q and the promise
- prototype for convenience when observing rejection,
- fulfillment and rejection, or just observing without
- affecting the resolution.
- - Renamed ``def`` (although ``def`` remains shimmed until
- the next major release) to ``master``.
- - Switched to using ``MessageChannel`` for next tick task
- enqueue in browsers that support it.
-
-## 0.5.0 - MINOR BACKWARD INCOMPATIBILITY
-
- - Exceptions are no longer reported when consumed.
- - Removed ``error`` from the API. Since exceptions are
- getting consumed, throwing them in an errback causes the
- exception to silently disappear. Use ``end``.
- - Added ``end`` as both an API method and a promise-chain
- ending method. It causes propagated rejections to be
- thrown, which allows Node to write stack traces and
- emit ``uncaughtException`` events, and browsers to
- likewise emit ``onerror`` and log to the console.
- - Added ``join`` and ``wait`` as promise chain functions,
- so you can wait for variadic promises, returning your own
- promise back, or join variadic promises, resolving with a
- callback that receives variadic fulfillment values.
-
-## 0.4.4
-
- - ``end`` no longer returns a promise. It is the end of the
- promise chain.
- - Stopped reporting thrown exceptions in ``when`` callbacks
- and errbacks. These must be explicitly reported through
- ``.end()``, ``.then(null, Q.error)``, or some other
- mechanism.
- - Added ``report`` as an API method, which can be used as
- an errback to report and propagate an error.
- - Added ``report`` as a promise-chain method, so an error
- can be reported if it passes such a gate.
-
-## 0.4.3
-
- - Fixed ``<script>`` support that regressed with 0.4.2
- because of "use strict" in the module system
- multi-plexer.
-
-## 0.4.2
-
- - Added support for RequireJS (jburke)
-
-## 0.4.1
-
- - Added an "end" method to the promise prototype,
- as a shorthand for waiting for the promise to
- be resolved gracefully, and failing to do so,
- to dump an error message.
-
-## 0.4.0 - BACKWARD INCOMPATIBLE*
-
- - *Removed the utility modules. NPM and Node no longer
- expose any module except the main module. These have
- been moved and merged into the "qq" package.
- - *In a non-CommonJS browser, q.js can be used as a script.
- It now creates a Q global variable.
- - Fixed thenable assimilation.
- - Fixed some issues with asap, when it resolves to
- undefined, or throws an exception.
-
-## 0.3.0 - BACKWARD-INCOMPATIBLE
-
- - The `post` method has been reverted to its original
- signature, as provided in Tyler Close's `ref_send` API.
- That is, `post` accepts two arguments, the second of
- which is an arbitrary object, but usually invocation
- arguments as an `Array`. To provide variadic arguments
- to `post`, there is a new `invoke` function that posts
- the variadic arguments to the value given in the first
- argument.
- - The `defined` method has been moved from `q` to `q/util`
- since it gets no use in practice but is still
- theoretically useful.
- - The `Promise` constructor has been renamed to
- `makePromise` to be consistent with the convention that
- functions that do not require the `new` keyword to be
- used as constructors have camelCase names.
- - The `isResolved` function has been renamed to
- `isFulfilled`. There is a new `isResolved` function that
- indicates whether a value is not a promise or, if it is a
- promise, whether it has been either fulfilled or
- rejected. The code has been revised to reflect this
- nuance in terminology.
-
-## 0.2.10
-
- - Added `join` to `"q/util"` for variadically joining
- multiple promises.
-
-## 0.2.9
-
- - The future-compatible `invoke` method has been added,
- to replace `post`, since `post` will become backward-
- incompatible in the next major release.
- - Exceptions thrown in the callbacks of a `when` call are
- now emitted to Node's `"uncaughtException"` `process`
- event in addition to being returned as a rejection reason.
-
-## 0.2.8
-
- - Exceptions thrown in the callbacks of a `when` call
- are now consumed, warned, and transformed into
- rejections of the promise returned by `when`.
-
-## 0.2.7
-
- - Fixed a minor bug in thenable assimilation, regressed
- because of the change in the forwarding protocol.
- - Fixed behavior of "q/util" `deep` method on dates and
- other primitives. Github issue #11.
-
-## 0.2.6
-
- - Thenables (objects with a "then" method) are accepted
- and provided, bringing this implementation of Q
- into conformance with Promises/A, B, and D.
- - Added `makePromise`, to replace the `Promise` function
- eventually.
- - Rejections are now also duck-typed. A rejection is a
- promise with a valueOf method that returns a rejection
- descriptor. A rejection descriptor has a
- "promiseRejected" property equal to "true" and a
- "reason" property corresponding to the rejection reason.
- - Altered the `makePromise` API such that the `fallback`
- method no longer receives a superfluous `resolved` method
- after the `operator`. The fallback method is responsible
- only for returning a resolution. This breaks an
- undocumented API, so third-party API's depending on the
- previous undocumented behavior may break.
-
-## 0.2.5
-
- - Changed promises into a duck-type such that multiple
- instances of the Q module can exchange promise objects.
- A promise is now defined as "an object that implements the
- `promiseSend(op, resolved, ...)` method and `valueOf`".
- - Exceptions in promises are now captured and returned
- as rejections.
-
-## 0.2.4
-
- - Fixed bug in `ref` that prevented `del` messages from
- being received (gozala)
- - Fixed a conflict with FireFox 4; constructor property
- is now read-only.
-
-## 0.2.3
-
- - Added `keys` message to promises and to the promise API.
-
-## 0.2.2
-
- - Added boilerplate to `q/queue` and `q/util`.
- - Fixed missing dependency to `q/queue`.
-
-## 0.2.1
-
- - The `resolve` and `reject` methods of `defer` objects now
- return the resolution promise for convenience.
- - Added `q/util`, which provides `step`, `delay`, `shallow`,
- `deep`, and three reduction orders.
- - Added `q/queue` module for a promise `Queue`.
- - Added `q-comm` to the list of compatible libraries.
- - Deprecated `defined` from `q`, with intent to move it to
- `q/util`.
-
-## 0.2.0 - BACKWARD INCOMPATIBLE
-
- - Changed post(ref, name, args) to variadic
- post(ref, name, ...args). BACKWARD INCOMPATIBLE
- - Added a def(value) method to annotate an object as being
- necessarily a local value that cannot be serialized, such
- that inter-process/worker/vat promise communication
- libraries will send messages to it, but never send it
- back.
- - Added a send(value, op, ...args) method to the public API, for
- forwarding messages to a value or promise in a future turn.
-
-## 0.1.9
-
- - Added isRejected() for testing whether a value is a rejected
- promise. isResolved() retains the behavior of stating
- that rejected promises are not resolved.
-
-## 0.1.8
-
- - Fixed isResolved(null) and isResolved(undefined) [issue #9]
- - Fixed a problem with the Object.create shim
-
-## 0.1.7
-
- - shimmed ES5 Object.create in addition to Object.freeze
- for compatibility on non-ES5 engines (gozala)
-
-## 0.1.6
-
- - Q.isResolved added
- - promise.valueOf() now returns the value of resolved
- and near values
- - asap retried
- - promises are frozen when possible
-
-## 0.1.5
-
- - fixed dependency list for Teleport (gozala)
- - all unit tests now pass (gozala)
-
-## 0.1.4
-
- - added support for Teleport as an engine (gozala)
- - simplified and updated methods for getting internal
- print and enqueue functions universally (gozala)
-
-## 0.1.3
-
- - fixed erroneous link to the q module in package.json
-
-## 0.1.2
-
- - restructured for overlay style package compatibility
-
-## 0.1.0
-
- - removed asap because it was broken, probably down to the
- philosophy.
-
-## 0.0.3
-
- - removed q-util
- - fixed asap so it returns a value if completed
-
-## 0.0.2
-
- - added q-util
-
-## 0.0.1
-
- - initial version
http://git-wip-us.apache.org/repos/asf/cordova-create/blob/9fb2883e/node_modules/cordova-fetch/node_modules/q/LICENSE
----------------------------------------------------------------------
diff --git a/node_modules/cordova-fetch/node_modules/q/LICENSE b/node_modules/cordova-fetch/node_modules/q/LICENSE
deleted file mode 100644
index 8a706b5..0000000
--- a/node_modules/cordova-fetch/node_modules/q/LICENSE
+++ /dev/null
@@ -1,18 +0,0 @@
-Copyright 2009\u20132014 Kristopher Michael Kowal. 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-create/blob/9fb2883e/node_modules/cordova-fetch/node_modules/q/README.md
----------------------------------------------------------------------
diff --git a/node_modules/cordova-fetch/node_modules/q/README.md b/node_modules/cordova-fetch/node_modules/q/README.md
deleted file mode 100644
index 9065bfa..0000000
--- a/node_modules/cordova-fetch/node_modules/q/README.md
+++ /dev/null
@@ -1,881 +0,0 @@
-[](http://travis-ci.org/kriskowal/q)
-
-<a href="http://promises-aplus.github.com/promises-spec">
- <img src="http://kriskowal.github.io/q/q.png"
- align="right" alt="Q logo" />
-</a>
-
-*This is Q version 1, from the `v1` branch in Git. This documentation applies to
-the latest of both the version 1 and version 0.9 release trains. These releases
-are stable. There will be no further releases of 0.9 after 0.9.7 which is nearly
-equivalent to version 1.0.0. All further releases of `q@~1.0` will be backward
-compatible. The version 2 release train introduces significant and
-backward-incompatible changes and is experimental at this time.*
-
-If a function cannot return a value or throw an exception without
-blocking, it can return a promise instead. A promise is an object
-that represents the return value or the thrown exception that the
-function may eventually provide. A promise can also be used as a
-proxy for a [remote object][Q-Connection] to overcome latency.
-
-[Q-Connection]: https://github.com/kriskowal/q-connection
-
-On the first pass, promises can mitigate the \u201c[Pyramid of
-Doom][POD]\u201d: the situation where code marches to the right faster
-than it marches forward.
-
-[POD]: http://calculist.org/blog/2011/12/14/why-coroutines-wont-work-on-the-web/
-
-```javascript
-step1(function (value1) {
- step2(value1, function(value2) {
- step3(value2, function(value3) {
- step4(value3, function(value4) {
- // Do something with value4
- });
- });
- });
-});
-```
-
-With a promise library, you can flatten the pyramid.
-
-```javascript
-Q.fcall(promisedStep1)
-.then(promisedStep2)
-.then(promisedStep3)
-.then(promisedStep4)
-.then(function (value4) {
- // Do something with value4
-})
-.catch(function (error) {
- // Handle any error from all above steps
-})
-.done();
-```
-
-With this approach, you also get implicit error propagation, just like `try`,
-`catch`, and `finally`. An error in `promisedStep1` will flow all the way to
-the `catch` function, where it\u2019s caught and handled. (Here `promisedStepN` is
-a version of `stepN` that returns a promise.)
-
-The callback approach is called an \u201cinversion of control\u201d.
-A function that accepts a callback instead of a return value
-is saying, \u201cDon\u2019t call me, I\u2019ll call you.\u201d. Promises
-[un-invert][IOC] the inversion, cleanly separating the input
-arguments from control flow arguments. This simplifies the
-use and creation of API\u2019s, particularly variadic,
-rest and spread arguments.
-
-[IOC]: http://www.slideshare.net/domenicdenicola/callbacks-promises-and-coroutines-oh-my-the-evolution-of-asynchronicity-in-javascript
-
-
-## Getting Started
-
-The Q module can be loaded as:
-
-- A ``<script>`` tag (creating a ``Q`` global variable): ~2.5 KB minified and
- gzipped.
-- A Node.js and CommonJS module, available in [npm](https://npmjs.org/) as
- the [q](https://npmjs.org/package/q) package
-- An AMD module
-- A [component](https://github.com/component/component) as ``microjs/q``
-- Using [bower](http://bower.io/) as `q#1.0.1`
-- Using [NuGet](http://nuget.org/) as [Q](https://nuget.org/packages/q)
-
-Q can exchange promises with jQuery, Dojo, When.js, WinJS, and more.
-
-## Resources
-
-Our [wiki][] contains a number of useful resources, including:
-
-- A method-by-method [Q API reference][reference].
-- A growing [examples gallery][examples], showing how Q can be used to make
- everything better. From XHR to database access to accessing the Flickr API,
- Q is there for you.
-- There are many libraries that produce and consume Q promises for everything
- from file system/database access or RPC to templating. For a list of some of
- the more popular ones, see [Libraries][].
-- If you want materials that introduce the promise concept generally, and the
- below tutorial isn't doing it for you, check out our collection of
- [presentations, blog posts, and podcasts][resources].
-- A guide for those [coming from jQuery's `$.Deferred`][jquery].
-
-We'd also love to have you join the Q-Continuum [mailing list][].
-
-[wiki]: https://github.com/kriskowal/q/wiki
-[reference]: https://github.com/kriskowal/q/wiki/API-Reference
-[examples]: https://github.com/kriskowal/q/wiki/Examples-Gallery
-[Libraries]: https://github.com/kriskowal/q/wiki/Libraries
-[resources]: https://github.com/kriskowal/q/wiki/General-Promise-Resources
-[jquery]: https://github.com/kriskowal/q/wiki/Coming-from-jQuery
-[mailing list]: https://groups.google.com/forum/#!forum/q-continuum
-
-
-## Tutorial
-
-Promises have a ``then`` method, which you can use to get the eventual
-return value (fulfillment) or thrown exception (rejection).
-
-```javascript
-promiseMeSomething()
-.then(function (value) {
-}, function (reason) {
-});
-```
-
-If ``promiseMeSomething`` returns a promise that gets fulfilled later
-with a return value, the first function (the fulfillment handler) will be
-called with the value. However, if the ``promiseMeSomething`` function
-gets rejected later by a thrown exception, the second function (the
-rejection handler) will be called with the exception.
-
-Note that resolution of a promise is always asynchronous: that is, the
-fulfillment or rejection handler will always be called in the next turn of the
-event loop (i.e. `process.nextTick` in Node). This gives you a nice
-guarantee when mentally tracing the flow of your code, namely that
-``then`` will always return before either handler is executed.
-
-In this tutorial, we begin with how to consume and work with promises. We'll
-talk about how to create them, and thus create functions like
-`promiseMeSomething` that return promises, [below](#the-beginning).
-
-
-### Propagation
-
-The ``then`` method returns a promise, which in this example, I\u2019m
-assigning to ``outputPromise``.
-
-```javascript
-var outputPromise = getInputPromise()
-.then(function (input) {
-}, function (reason) {
-});
-```
-
-The ``outputPromise`` variable becomes a new promise for the return
-value of either handler. Since a function can only either return a
-value or throw an exception, only one handler will ever be called and it
-will be responsible for resolving ``outputPromise``.
-
-- If you return a value in a handler, ``outputPromise`` will get
- fulfilled.
-
-- If you throw an exception in a handler, ``outputPromise`` will get
- rejected.
-
-- If you return a **promise** in a handler, ``outputPromise`` will
- \u201cbecome\u201d that promise. Being able to become a new promise is useful
- for managing delays, combining results, or recovering from errors.
-
-If the ``getInputPromise()`` promise gets rejected and you omit the
-rejection handler, the **error** will go to ``outputPromise``:
-
-```javascript
-var outputPromise = getInputPromise()
-.then(function (value) {
-});
-```
-
-If the input promise gets fulfilled and you omit the fulfillment handler, the
-**value** will go to ``outputPromise``:
-
-```javascript
-var outputPromise = getInputPromise()
-.then(null, function (error) {
-});
-```
-
-Q promises provide a ``fail`` shorthand for ``then`` when you are only
-interested in handling the error:
-
-```javascript
-var outputPromise = getInputPromise()
-.fail(function (error) {
-});
-```
-
-If you are writing JavaScript for modern engines only or using
-CoffeeScript, you may use `catch` instead of `fail`.
-
-Promises also have a ``fin`` function that is like a ``finally`` clause.
-The final handler gets called, with no arguments, when the promise
-returned by ``getInputPromise()`` either returns a value or throws an
-error. The value returned or error thrown by ``getInputPromise()``
-passes directly to ``outputPromise`` unless the final handler fails, and
-may be delayed if the final handler returns a promise.
-
-```javascript
-var outputPromise = getInputPromise()
-.fin(function () {
- // close files, database connections, stop servers, conclude tests
-});
-```
-
-- If the handler returns a value, the value is ignored
-- If the handler throws an error, the error passes to ``outputPromise``
-- If the handler returns a promise, ``outputPromise`` gets postponed. The
- eventual value or error has the same effect as an immediate return
- value or thrown error: a value would be ignored, an error would be
- forwarded.
-
-If you are writing JavaScript for modern engines only or using
-CoffeeScript, you may use `finally` instead of `fin`.
-
-### Chaining
-
-There are two ways to chain promises. You can chain promises either
-inside or outside handlers. The next two examples are equivalent.
-
-```javascript
-return getUsername()
-.then(function (username) {
- return getUser(username)
- .then(function (user) {
- // if we get here without an error,
- // the value returned here
- // or the exception thrown here
- // resolves the promise returned
- // by the first line
- })
-});
-```
-
-```javascript
-return getUsername()
-.then(function (username) {
- return getUser(username);
-})
-.then(function (user) {
- // if we get here without an error,
- // the value returned here
- // or the exception thrown here
- // resolves the promise returned
- // by the first line
-});
-```
-
-The only difference is nesting. It\u2019s useful to nest handlers if you
-need to capture multiple input values in your closure.
-
-```javascript
-function authenticate() {
- return getUsername()
- .then(function (username) {
- return getUser(username);
- })
- // chained because we will not need the user name in the next event
- .then(function (user) {
- return getPassword()
- // nested because we need both user and password next
- .then(function (password) {
- if (user.passwordHash !== hash(password)) {
- throw new Error("Can't authenticate");
- }
- });
- });
-}
-```
-
-
-### Combination
-
-You can turn an array of promises into a promise for the whole,
-fulfilled array using ``all``.
-
-```javascript
-return Q.all([
- eventualAdd(2, 2),
- eventualAdd(10, 20)
-]);
-```
-
-If you have a promise for an array, you can use ``spread`` as a
-replacement for ``then``. The ``spread`` function \u201cspreads\u201d the
-values over the arguments of the fulfillment handler. The rejection handler
-will get called at the first sign of failure. That is, whichever of
-the received promises fails first gets handled by the rejection handler.
-
-```javascript
-function eventualAdd(a, b) {
- return Q.spread([a, b], function (a, b) {
- return a + b;
- })
-}
-```
-
-But ``spread`` calls ``all`` initially, so you can skip it in chains.
-
-```javascript
-return getUsername()
-.then(function (username) {
- return [username, getUser(username)];
-})
-.spread(function (username, user) {
-});
-```
-
-The ``all`` function returns a promise for an array of values. When this
-promise is fulfilled, the array contains the fulfillment values of the original
-promises, in the same order as those promises. If one of the given promises
-is rejected, the returned promise is immediately rejected, not waiting for the
-rest of the batch. If you want to wait for all of the promises to either be
-fulfilled or rejected, you can use ``allSettled``.
-
-```javascript
-Q.allSettled(promises)
-.then(function (results) {
- results.forEach(function (result) {
- if (result.state === "fulfilled") {
- var value = result.value;
- } else {
- var reason = result.reason;
- }
- });
-});
-```
-
-The ``any`` function accepts an array of promises and returns a promise that is
-fulfilled by the first given promise to be fulfilled, or rejected if all of the
-given promises are rejected.
-
-```javascript
-Q.any(promises)
-.then(function (first) {
- // Any of the promises was fulfilled.
-}, function (error) {
- // All of the promises were rejected.
-});
-```
-
-### Sequences
-
-If you have a number of promise-producing functions that need
-to be run sequentially, you can of course do so manually:
-
-```javascript
-return foo(initialVal).then(bar).then(baz).then(qux);
-```
-
-However, if you want to run a dynamically constructed sequence of
-functions, you'll want something like this:
-
-```javascript
-var funcs = [foo, bar, baz, qux];
-
-var result = Q(initialVal);
-funcs.forEach(function (f) {
- result = result.then(f);
-});
-return result;
-```
-
-You can make this slightly more compact using `reduce`:
-
-```javascript
-return funcs.reduce(function (soFar, f) {
- return soFar.then(f);
-}, Q(initialVal));
-```
-
-Or, you could use the ultra-compact version:
-
-```javascript
-return funcs.reduce(Q.when, Q(initialVal));
-```
-
-### Handling Errors
-
-One sometimes-unintuive aspect of promises is that if you throw an
-exception in the fulfillment handler, it will not be caught by the error
-handler.
-
-```javascript
-return foo()
-.then(function (value) {
- throw new Error("Can't bar.");
-}, function (error) {
- // We only get here if "foo" fails
-});
-```
-
-To see why this is, consider the parallel between promises and
-``try``/``catch``. We are ``try``-ing to execute ``foo()``: the error
-handler represents a ``catch`` for ``foo()``, while the fulfillment handler
-represents code that happens *after* the ``try``/``catch`` block.
-That code then needs its own ``try``/``catch`` block.
-
-In terms of promises, this means chaining your rejection handler:
-
-```javascript
-return foo()
-.then(function (value) {
- throw new Error("Can't bar.");
-})
-.fail(function (error) {
- // We get here with either foo's error or bar's error
-});
-```
-
-### Progress Notification
-
-It's possible for promises to report their progress, e.g. for tasks that take a
-long time like a file upload. Not all promises will implement progress
-notifications, but for those that do, you can consume the progress values using
-a third parameter to ``then``:
-
-```javascript
-return uploadFile()
-.then(function () {
- // Success uploading the file
-}, function (err) {
- // There was an error, and we get the reason for error
-}, function (progress) {
- // We get notified of the upload's progress as it is executed
-});
-```
-
-Like `fail`, Q also provides a shorthand for progress callbacks
-called `progress`:
-
-```javascript
-return uploadFile().progress(function (progress) {
- // We get notified of the upload's progress
-});
-```
-
-### The End
-
-When you get to the end of a chain of promises, you should either
-return the last promise or end the chain. Since handlers catch
-errors, it\u2019s an unfortunate pattern that the exceptions can go
-unobserved.
-
-So, either return it,
-
-```javascript
-return foo()
-.then(function () {
- return "bar";
-});
-```
-
-Or, end it.
-
-```javascript
-foo()
-.then(function () {
- return "bar";
-})
-.done();
-```
-
-Ending a promise chain makes sure that, if an error doesn\u2019t get
-handled before the end, it will get rethrown and reported.
-
-This is a stopgap. We are exploring ways to make unhandled errors
-visible without any explicit handling.
-
-
-### The Beginning
-
-Everything above assumes you get a promise from somewhere else. This
-is the common case. Every once in a while, you will need to create a
-promise from scratch.
-
-#### Using ``Q.fcall``
-
-You can create a promise from a value using ``Q.fcall``. This returns a
-promise for 10.
-
-```javascript
-return Q.fcall(function () {
- return 10;
-});
-```
-
-You can also use ``fcall`` to get a promise for an exception.
-
-```javascript
-return Q.fcall(function () {
- throw new Error("Can't do it");
-});
-```
-
-As the name implies, ``fcall`` can call functions, or even promised
-functions. This uses the ``eventualAdd`` function above to add two
-numbers.
-
-```javascript
-return Q.fcall(eventualAdd, 2, 2);
-```
-
-
-#### Using Deferreds
-
-If you have to interface with asynchronous functions that are callback-based
-instead of promise-based, Q provides a few shortcuts (like ``Q.nfcall`` and
-friends). But much of the time, the solution will be to use *deferreds*.
-
-```javascript
-var deferred = Q.defer();
-FS.readFile("foo.txt", "utf-8", function (error, text) {
- if (error) {
- deferred.reject(new Error(error));
- } else {
- deferred.resolve(text);
- }
-});
-return deferred.promise;
-```
-
-Note that a deferred can be resolved with a value or a promise. The
-``reject`` function is a shorthand for resolving with a rejected
-promise.
-
-```javascript
-// this:
-deferred.reject(new Error("Can't do it"));
-
-// is shorthand for:
-var rejection = Q.fcall(function () {
- throw new Error("Can't do it");
-});
-deferred.resolve(rejection);
-```
-
-This is a simplified implementation of ``Q.delay``.
-
-```javascript
-function delay(ms) {
- var deferred = Q.defer();
- setTimeout(deferred.resolve, ms);
- return deferred.promise;
-}
-```
-
-This is a simplified implementation of ``Q.timeout``
-
-```javascript
-function timeout(promise, ms) {
- var deferred = Q.defer();
- Q.when(promise, deferred.resolve);
- delay(ms).then(function () {
- deferred.reject(new Error("Timed out"));
- });
- return deferred.promise;
-}
-```
-
-Finally, you can send a progress notification to the promise with
-``deferred.notify``.
-
-For illustration, this is a wrapper for XML HTTP requests in the browser. Note
-that a more [thorough][XHR] implementation would be in order in practice.
-
-[XHR]: https://github.com/montagejs/mr/blob/71e8df99bb4f0584985accd6f2801ef3015b9763/browser.js#L29-L73
-
-```javascript
-function requestOkText(url) {
- var request = new XMLHttpRequest();
- var deferred = Q.defer();
-
- request.open("GET", url, true);
- request.onload = onload;
- request.onerror = onerror;
- request.onprogress = onprogress;
- request.send();
-
- function onload() {
- if (request.status === 200) {
- deferred.resolve(request.responseText);
- } else {
- deferred.reject(new Error("Status code was " + request.status));
- }
- }
-
- function onerror() {
- deferred.reject(new Error("Can't XHR " + JSON.stringify(url)));
- }
-
- function onprogress(event) {
- deferred.notify(event.loaded / event.total);
- }
-
- return deferred.promise;
-}
-```
-
-Below is an example of how to use this ``requestOkText`` function:
-
-```javascript
-requestOkText("http://localhost:3000")
-.then(function (responseText) {
- // If the HTTP response returns 200 OK, log the response text.
- console.log(responseText);
-}, function (error) {
- // If there's an error or a non-200 status code, log the error.
- console.error(error);
-}, function (progress) {
- // Log the progress as it comes in.
- console.log("Request progress: " + Math.round(progress * 100) + "%");
-});
-```
-
-#### Using `Q.Promise`
-
-This is an alternative promise-creation API that has the same power as
-the deferred concept, but without introducing another conceptual entity.
-
-Rewriting the `requestOkText` example above using `Q.Promise`:
-
-```javascript
-function requestOkText(url) {
- return Q.Promise(function(resolve, reject, notify) {
- var request = new XMLHttpRequest();
-
- request.open("GET", url, true);
- request.onload = onload;
- request.onerror = onerror;
- request.onprogress = onprogress;
- request.send();
-
- function onload() {
- if (request.status === 200) {
- resolve(request.responseText);
- } else {
- reject(new Error("Status code was " + request.status));
- }
- }
-
- function onerror() {
- reject(new Error("Can't XHR " + JSON.stringify(url)));
- }
-
- function onprogress(event) {
- notify(event.loaded / event.total);
- }
- });
-}
-```
-
-If `requestOkText` were to throw an exception, the returned promise would be
-rejected with that thrown exception as the rejection reason.
-
-### The Middle
-
-If you are using a function that may return a promise, but just might
-return a value if it doesn\u2019t need to defer, you can use the \u201cstatic\u201d
-methods of the Q library.
-
-The ``when`` function is the static equivalent for ``then``.
-
-```javascript
-return Q.when(valueOrPromise, function (value) {
-}, function (error) {
-});
-```
-
-All of the other methods on a promise have static analogs with the
-same name.
-
-The following are equivalent:
-
-```javascript
-return Q.all([a, b]);
-```
-
-```javascript
-return Q.fcall(function () {
- return [a, b];
-})
-.all();
-```
-
-When working with promises provided by other libraries, you should
-convert it to a Q promise. Not all promise libraries make the same
-guarantees as Q and certainly don\u2019t provide all of the same methods.
-Most libraries only provide a partially functional ``then`` method.
-This thankfully is all we need to turn them into vibrant Q promises.
-
-```javascript
-return Q($.ajax(...))
-.then(function () {
-});
-```
-
-If there is any chance that the promise you receive is not a Q promise
-as provided by your library, you should wrap it using a Q function.
-You can even use ``Q.invoke`` as a shorthand.
-
-```javascript
-return Q.invoke($, 'ajax', ...)
-.then(function () {
-});
-```
-
-
-### Over the Wire
-
-A promise can serve as a proxy for another object, even a remote
-object. There are methods that allow you to optimistically manipulate
-properties or call functions. All of these interactions return
-promises, so they can be chained.
-
-```
-direct manipulation using a promise as a proxy
--------------------------- -------------------------------
-value.foo promise.get("foo")
-value.foo = value promise.put("foo", value)
-delete value.foo promise.del("foo")
-value.foo(...args) promise.post("foo", [args])
-value.foo(...args) promise.invoke("foo", ...args)
-value(...args) promise.fapply([args])
-value(...args) promise.fcall(...args)
-```
-
-If the promise is a proxy for a remote object, you can shave
-round-trips by using these functions instead of ``then``. To take
-advantage of promises for remote objects, check out [Q-Connection][].
-
-[Q-Connection]: https://github.com/kriskowal/q-connection
-
-Even in the case of non-remote objects, these methods can be used as
-shorthand for particularly-simple fulfillment handlers. For example, you
-can replace
-
-```javascript
-return Q.fcall(function () {
- return [{ foo: "bar" }, { foo: "baz" }];
-})
-.then(function (value) {
- return value[0].foo;
-});
-```
-
-with
-
-```javascript
-return Q.fcall(function () {
- return [{ foo: "bar" }, { foo: "baz" }];
-})
-.get(0)
-.get("foo");
-```
-
-
-### Adapting Node
-
-If you're working with functions that make use of the Node.js callback pattern,
-where callbacks are in the form of `function(err, result)`, Q provides a few
-useful utility functions for converting between them. The most straightforward
-are probably `Q.nfcall` and `Q.nfapply` ("Node function call/apply") for calling
-Node.js-style functions and getting back a promise:
-
-```javascript
-return Q.nfcall(FS.readFile, "foo.txt", "utf-8");
-return Q.nfapply(FS.readFile, ["foo.txt", "utf-8"]);
-```
-
-If you are working with methods, instead of simple functions, you can easily
-run in to the usual problems where passing a method to another function\u2014like
-`Q.nfcall`\u2014"un-binds" the method from its owner. To avoid this, you can either
-use `Function.prototype.bind` or some nice shortcut methods we provide:
-
-```javascript
-return Q.ninvoke(redisClient, "get", "user:1:id");
-return Q.npost(redisClient, "get", ["user:1:id"]);
-```
-
-You can also create reusable wrappers with `Q.denodeify` or `Q.nbind`:
-
-```javascript
-var readFile = Q.denodeify(FS.readFile);
-return readFile("foo.txt", "utf-8");
-
-var redisClientGet = Q.nbind(redisClient.get, redisClient);
-return redisClientGet("user:1:id");
-```
-
-Finally, if you're working with raw deferred objects, there is a
-`makeNodeResolver` method on deferreds that can be handy:
-
-```javascript
-var deferred = Q.defer();
-FS.readFile("foo.txt", "utf-8", deferred.makeNodeResolver());
-return deferred.promise;
-```
-
-### Long Stack Traces
-
-Q comes with optional support for \u201clong stack traces,\u201d wherein the `stack`
-property of `Error` rejection reasons is rewritten to be traced along
-asynchronous jumps instead of stopping at the most recent one. As an example:
-
-```js
-function theDepthsOfMyProgram() {
- Q.delay(100).done(function explode() {
- throw new Error("boo!");
- });
-}
-
-theDepthsOfMyProgram();
-```
-
-usually would give a rather unhelpful stack trace looking something like
-
-```
-Error: boo!
- at explode (/path/to/test.js:3:11)
- at _fulfilled (/path/to/test.js:q:54)
- at resolvedValue.promiseDispatch.done (/path/to/q.js:823:30)
- at makePromise.promise.promiseDispatch (/path/to/q.js:496:13)
- at pending (/path/to/q.js:397:39)
- at process.startup.processNextTick.process._tickCallback (node.js:244:9)
-```
-
-But, if you turn this feature on by setting
-
-```js
-Q.longStackSupport = true;
-```
-
-then the above code gives a nice stack trace to the tune of
-
-```
-Error: boo!
- at explode (/path/to/test.js:3:11)
-From previous event:
- at theDepthsOfMyProgram (/path/to/test.js:2:16)
- at Object.<anonymous> (/path/to/test.js:7:1)
-```
-
-Note how you can see the function that triggered the async operation in the
-stack trace! This is very helpful for debugging, as otherwise you end up getting
-only the first line, plus a bunch of Q internals, with no sign of where the
-operation started.
-
-In node.js, this feature can also be enabled through the Q_DEBUG environment
-variable:
-
-```
-Q_DEBUG=1 node server.js
-```
-
-This will enable long stack support in every instance of Q.
-
-This feature does come with somewhat-serious performance and memory overhead,
-however. If you're working with lots of promises, or trying to scale a server
-to many users, you should probably keep it off. But in development, go for it!
-
-## Tests
-
-You can view the results of the Q test suite [in your browser][tests]!
-
-[tests]: https://rawgithub.com/kriskowal/q/v1/spec/q-spec.html
-
-## License
-
-Copyright 2009\u20132015 Kristopher Michael Kowal and contributors
-MIT License (enclosed)
-
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@cordova.apache.org
For additional commands, e-mail: commits-help@cordova.apache.org