246 lines
6 KiB
JavaScript
246 lines
6 KiB
JavaScript
![]() |
exports.alphasort = alphasort
|
||
|
exports.alphasorti = alphasorti
|
||
|
exports.setopts = setopts
|
||
|
exports.ownProp = ownProp
|
||
|
exports.makeAbs = makeAbs
|
||
|
exports.finish = finish
|
||
|
exports.mark = mark
|
||
|
exports.isIgnored = isIgnored
|
||
|
exports.childrenIgnored = childrenIgnored
|
||
|
|
||
|
function ownProp (obj, field) {
|
||
|
return Object.prototype.hasOwnProperty.call(obj, field)
|
||
|
}
|
||
|
|
||
|
var path = require("path")
|
||
|
var minimatch = require("minimatch")
|
||
|
var isAbsolute = require("path-is-absolute")
|
||
|
var Minimatch = minimatch.Minimatch
|
||
|
|
||
|
function alphasorti (a, b) {
|
||
|
return a.toLowerCase().localeCompare(b.toLowerCase())
|
||
|
}
|
||
|
|
||
|
function alphasort (a, b) {
|
||
|
return a.localeCompare(b)
|
||
|
}
|
||
|
|
||
|
function setupIgnores (self, options) {
|
||
|
self.ignore = options.ignore || []
|
||
|
|
||
|
if (!Array.isArray(self.ignore))
|
||
|
self.ignore = [self.ignore]
|
||
|
|
||
|
if (self.ignore.length) {
|
||
|
self.ignore = self.ignore.map(ignoreMap)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
function ignoreMap (pattern) {
|
||
|
var gmatcher = null
|
||
|
if (pattern.slice(-3) === '/**') {
|
||
|
var gpattern = pattern.replace(/(\/\*\*)+$/, '')
|
||
|
gmatcher = new Minimatch(gpattern)
|
||
|
}
|
||
|
|
||
|
return {
|
||
|
matcher: new Minimatch(pattern),
|
||
|
gmatcher: gmatcher
|
||
|
}
|
||
|
}
|
||
|
|
||
|
function setopts (self, pattern, options) {
|
||
|
if (!options)
|
||
|
options = {}
|
||
|
|
||
|
// base-matching: just use globstar for that.
|
||
|
if (options.matchBase && -1 === pattern.indexOf("/")) {
|
||
|
if (options.noglobstar) {
|
||
|
throw new Error("base matching requires globstar")
|
||
|
}
|
||
|
pattern = "**/" + pattern
|
||
|
}
|
||
|
|
||
|
self.silent = !!options.silent
|
||
|
self.pattern = pattern
|
||
|
self.strict = options.strict !== false
|
||
|
self.realpath = !!options.realpath
|
||
|
self.realpathCache = options.realpathCache || Object.create(null)
|
||
|
self.follow = !!options.follow
|
||
|
self.dot = !!options.dot
|
||
|
self.mark = !!options.mark
|
||
|
self.nodir = !!options.nodir
|
||
|
if (self.nodir)
|
||
|
self.mark = true
|
||
|
self.sync = !!options.sync
|
||
|
self.nounique = !!options.nounique
|
||
|
self.nonull = !!options.nonull
|
||
|
self.nosort = !!options.nosort
|
||
|
self.nocase = !!options.nocase
|
||
|
self.stat = !!options.stat
|
||
|
self.noprocess = !!options.noprocess
|
||
|
|
||
|
self.maxLength = options.maxLength || Infinity
|
||
|
self.cache = options.cache || Object.create(null)
|
||
|
self.statCache = options.statCache || Object.create(null)
|
||
|
self.symlinks = options.symlinks || Object.create(null)
|
||
|
|
||
|
setupIgnores(self, options)
|
||
|
|
||
|
self.changedCwd = false
|
||
|
var cwd = process.cwd()
|
||
|
if (!ownProp(options, "cwd"))
|
||
|
self.cwd = cwd
|
||
|
else {
|
||
|
self.cwd = options.cwd
|
||
|
self.changedCwd = path.resolve(options.cwd) !== cwd
|
||
|
}
|
||
|
|
||
|
self.root = options.root || path.resolve(self.cwd, "/")
|
||
|
self.root = path.resolve(self.root)
|
||
|
if (process.platform === "win32")
|
||
|
self.root = self.root.replace(/\\/g, "/")
|
||
|
|
||
|
self.nomount = !!options.nomount
|
||
|
|
||
|
// disable comments and negation unless the user explicitly
|
||
|
// passes in false as the option.
|
||
|
options.nonegate = options.nonegate === false ? false : true
|
||
|
options.nocomment = options.nocomment === false ? false : true
|
||
|
deprecationWarning(options)
|
||
|
|
||
|
self.minimatch = new Minimatch(pattern, options)
|
||
|
self.options = self.minimatch.options
|
||
|
}
|
||
|
|
||
|
// TODO(isaacs): remove entirely in v6
|
||
|
// exported to reset in tests
|
||
|
exports.deprecationWarned
|
||
|
function deprecationWarning(options) {
|
||
|
if (!options.nonegate || !options.nocomment) {
|
||
|
if (process.noDeprecation !== true && !exports.deprecationWarned) {
|
||
|
var msg = 'glob WARNING: comments and negation will be disabled in v6'
|
||
|
if (process.throwDeprecation)
|
||
|
throw new Error(msg)
|
||
|
else if (process.traceDeprecation)
|
||
|
console.trace(msg)
|
||
|
else
|
||
|
console.error(msg)
|
||
|
|
||
|
exports.deprecationWarned = true
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
function finish (self) {
|
||
|
var nou = self.nounique
|
||
|
var all = nou ? [] : Object.create(null)
|
||
|
|
||
|
for (var i = 0, l = self.matches.length; i < l; i ++) {
|
||
|
var matches = self.matches[i]
|
||
|
if (!matches || Object.keys(matches).length === 0) {
|
||
|
if (self.nonull) {
|
||
|
// do like the shell, and spit out the literal glob
|
||
|
var literal = self.minimatch.globSet[i]
|
||
|
if (nou)
|
||
|
all.push(literal)
|
||
|
else
|
||
|
all[literal] = true
|
||
|
}
|
||
|
} else {
|
||
|
// had matches
|
||
|
var m = Object.keys(matches)
|
||
|
if (nou)
|
||
|
all.push.apply(all, m)
|
||
|
else
|
||
|
m.forEach(function (m) {
|
||
|
all[m] = true
|
||
|
})
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if (!nou)
|
||
|
all = Object.keys(all)
|
||
|
|
||
|
if (!self.nosort)
|
||
|
all = all.sort(self.nocase ? alphasorti : alphasort)
|
||
|
|
||
|
// at *some* point we statted all of these
|
||
|
if (self.mark) {
|
||
|
for (var i = 0; i < all.length; i++) {
|
||
|
all[i] = self._mark(all[i])
|
||
|
}
|
||
|
if (self.nodir) {
|
||
|
all = all.filter(function (e) {
|
||
|
return !(/\/$/.test(e))
|
||
|
})
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if (self.ignore.length)
|
||
|
all = all.filter(function(m) {
|
||
|
return !isIgnored(self, m)
|
||
|
})
|
||
|
|
||
|
self.found = all
|
||
|
}
|
||
|
|
||
|
function mark (self, p) {
|
||
|
var abs = makeAbs(self, p)
|
||
|
var c = self.cache[abs]
|
||
|
var m = p
|
||
|
if (c) {
|
||
|
var isDir = c === 'DIR' || Array.isArray(c)
|
||
|
var slash = p.slice(-1) === '/'
|
||
|
|
||
|
if (isDir && !slash)
|
||
|
m += '/'
|
||
|
else if (!isDir && slash)
|
||
|
m = m.slice(0, -1)
|
||
|
|
||
|
if (m !== p) {
|
||
|
var mabs = makeAbs(self, m)
|
||
|
self.statCache[mabs] = self.statCache[abs]
|
||
|
self.cache[mabs] = self.cache[abs]
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return m
|
||
|
}
|
||
|
|
||
|
// lotta situps...
|
||
|
function makeAbs (self, f) {
|
||
|
var abs = f
|
||
|
if (f.charAt(0) === '/') {
|
||
|
abs = path.join(self.root, f)
|
||
|
} else if (isAbsolute(f) || f === '') {
|
||
|
abs = f
|
||
|
} else if (self.changedCwd) {
|
||
|
abs = path.resolve(self.cwd, f)
|
||
|
} else {
|
||
|
abs = path.resolve(f)
|
||
|
}
|
||
|
return abs
|
||
|
}
|
||
|
|
||
|
|
||
|
// Return true, if pattern ends with globstar '**', for the accompanying parent directory.
|
||
|
// Ex:- If node_modules/** is the pattern, add 'node_modules' to ignore list along with it's contents
|
||
|
function isIgnored (self, path) {
|
||
|
if (!self.ignore.length)
|
||
|
return false
|
||
|
|
||
|
return self.ignore.some(function(item) {
|
||
|
return item.matcher.match(path) || !!(item.gmatcher && item.gmatcher.match(path))
|
||
|
})
|
||
|
}
|
||
|
|
||
|
function childrenIgnored (self, path) {
|
||
|
if (!self.ignore.length)
|
||
|
return false
|
||
|
|
||
|
return self.ignore.some(function(item) {
|
||
|
return !!(item.gmatcher && item.gmatcher.match(path))
|
||
|
})
|
||
|
}
|