glob@4.2.1

more fasterer and less testy

1 files changed, 451 insertions, 551 deletions

diff --git a/node_modules/glob/glob.js b/node_modules/glob/glob.js
index 564f3b121..fd4332a05 100644
--- a/node_modules/glob/glob.js
+++ b/node_modules/glob/glob.js
@@ -1,24 +1,30 @@
 // Approach:
 //
 // 1. Get the minimatch set
-// 2. For each pattern in the set, PROCESS(pattern)
+// 2. For each pattern in the set, PROCESS(pattern, false)
 // 3. Store matches per-set, then uniq them
 //
-// PROCESS(pattern)
+// PROCESS(pattern, inGlobStar)
 // Get the first [n] items from pattern that are all strings
 // Join these together.  This is PREFIX.
 //   If there is no more remaining, then stat(PREFIX) and
 //   add to matches if it succeeds.  END.
-// readdir(PREFIX) as ENTRIES
-//   If fails, END
+//
+// If inGlobStar and PREFIX is symlink and points to dir
+//   set ENTRIES = []
+// else readdir(PREFIX) as ENTRIES
+//   If fail, END
+//
+// with ENTRIES
 //   If pattern[n] is GLOBSTAR
 //     // handle the case where the globstar match is empty
 //     // by pruning it out, and testing the resulting pattern
-//     PROCESS(pattern[0..n] + pattern[n+1 .. $])
+//     PROCESS(pattern[0..n] + pattern[n+1 .. $], false)
 //     // handle other cases.
 //     for ENTRY in ENTRIES (not dotfiles)
 //       // attach globstar + tail onto the entry
-//       PROCESS(pattern[0..n] + ENTRY + pattern[n .. $])
+//       // Mark that this entry is a globstar match
+//       PROCESS(pattern[0..n] + ENTRY + pattern[n .. $], true)
 //
 //   else // not globstar
 //     for ENTRY in ENTRIES (not dotfiles, unless pattern[n] is dot)
@@ -32,146 +38,81 @@
 //   `true` for files, and [children,...] for directories, or `false` for
 //   things that don't exist.
 
-
-
 module.exports = glob
 
-var fs = require("graceful-fs")
-, minimatch = require("minimatch")
-, Minimatch = minimatch.Minimatch
-, inherits = require("inherits")
-, EE = require("events").EventEmitter
-, path = require("path")
-, isDir = {}
-, assert = require("assert").ok
-, once = require("once")
+var fs = require("fs")
+var minimatch = require("minimatch")
+var Minimatch = minimatch.Minimatch
+var inherits = require("inherits")
+var EE = require("events").EventEmitter
+var path = require("path")
+var assert = require("assert")
+var globSync = require("./sync.js")
+var common = require("./common.js")
+var alphasort = common.alphasort
+var alphasorti = common.alphasorti
+var isAbsolute = common.isAbsolute
+var setopts = common.setopts
+var ownProp = common.ownProp
+var inflight = require("inflight")
+var util = require("util")
+
+var once = require("once")
 
 function glob (pattern, options, cb) {
   if (typeof options === "function") cb = options, options = {}
   if (!options) options = {}
 
-  if (typeof options === "number") {
-    deprecated()
-    return
+  if (options.sync) {
+    if (cb)
+      throw new TypeError('callback provided to sync glob')
+    return globSync(pattern, options)
   }
 
-  var g = new Glob(pattern, options, cb)
-  return g.sync ? g.found : g
+  return new Glob(pattern, options, cb)
 }
 
-glob.fnmatch = deprecated
+glob.sync = globSync
+var GlobSync = glob.GlobSync = globSync.GlobSync
 
-function deprecated () {
-  throw new Error("glob's interface has changed. Please see the docs.")
-}
+// old api surface
+glob.glob = glob
 
-glob.sync = globSync
-function globSync (pattern, options) {
-  if (typeof options === "number") {
-    deprecated()
-    return
+glob.hasMagic = function (pattern, options_) {
+  var options = util._extend({}, options_)
+  options.noprocess = true
+
+  var g = new Glob(pattern, options)
+  var set = g.minimatch.set
+  if (set.length > 1)
+    return true
+
+  for (var j = 0; j < set[0].length; j++) {
+    if (typeof set[0][j] !== 'string')
+      return true
   }
 
-  options = options || {}
-  options.sync = true
-  return glob(pattern, options)
+  return false
 }
 
-this._processingEmitQueue = false
-
 glob.Glob = Glob
 inherits(Glob, EE)
 function Glob (pattern, options, cb) {
-  if (!(this instanceof Glob)) {
-    return new Glob(pattern, options, cb)
-  }
-
   if (typeof options === "function") {
     cb = options
     options = null
   }
 
-  if (typeof cb === "function") {
-    cb = once(cb)
-    this.on("error", cb)
-    this.on("end", function (matches) {
-      cb(null, matches)
-    })
-  }
-
-  options = options || {}
-
-  this._endEmitted = false
-  this.EOF = {}
-  this._emitQueue = []
-
-  this.paused = false
-  this._processingEmitQueue = false
-
-  this.maxDepth = options.maxDepth || 1000
-  this.maxLength = options.maxLength || Infinity
-  this.cache = options.cache || {}
-  this.statCache = options.statCache || {}
-
-  this.changedCwd = false
-  var cwd = process.cwd()
-  if (!options.hasOwnProperty("cwd")) this.cwd = cwd
-  else {
-    this.cwd = options.cwd
-    this.changedCwd = path.resolve(options.cwd) !== cwd
-  }
-
-  this.root = options.root || path.resolve(this.cwd, "/")
-  this.root = path.resolve(this.root)
-  if (process.platform === "win32")
-    this.root = this.root.replace(/\\/g, "/")
-
-  this.nomount = !!options.nomount
-
-  if (!pattern) {
-    throw new Error("must provide pattern")
-  }
-
-  // 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
+  if (options && options.sync) {
+    if (cb)
+      throw new TypeError('callback provided to sync glob')
+    return new GlobSync(pattern, options)
   }
 
-  this.strict = options.strict !== false
-  this.dot = !!options.dot
-  this.mark = !!options.mark
-  this.sync = !!options.sync
-  this.nounique = !!options.nounique
-  this.nonull = !!options.nonull
-  this.nosort = !!options.nosort
-  this.nocase = !!options.nocase
-  this.stat = !!options.stat
-
-  this.debug = !!options.debug || !!options.globDebug
-
-  if (/\bglob\b/.test(process.env.NODE_DEBUG || ''))
-    this.debug = true
-
-  if (this.debug)
-    this.log = console.error
-
-  this.silent = !!options.silent
-
-  var mm = this.minimatch = new Minimatch(pattern, options)
-  this.options = mm.options
-  pattern = this.pattern = mm.pattern
-
-  this.error = null
-  this.aborted = false
-
-  // list of all the patterns that ** has resolved do, so
-  // we can avoid visiting multiple times.
-  this._globstars = {}
+  if (!(this instanceof Glob))
+    return new Glob(pattern, options, cb)
 
-  EE.call(this)
+  setopts(this, pattern, options)
 
   // process each pattern in the minimatch set
   var n = this.minimatch.set.length
@@ -182,93 +123,56 @@ function Glob (pattern, options, cb) {
   // Keep them as a list so we can fill in when nonull is set.
   this.matches = new Array(n)
 
-  if (this.minimatch.set.length === 0) {
-    return process.nextTick(this._finish.bind(this))
-  }
-
-  this.minimatch.set.forEach(iterator.bind(this))
-  function iterator (pattern, i, set) {
-    this._process(pattern, 0, i, function (er) {
-      if (er) this.emit("error", er)
-      if (-- n <= 0) this._finish()
+  if (typeof cb === "function") {
+    cb = once(cb)
+    this.on("error", cb)
+    this.on("end", function (matches) {
+      cb(null, matches)
     })
   }
-}
 
-Glob.prototype.log = function () {}
+  var self = this
+  var n = this.minimatch.set.length
+  this._processing = 0
+  this.matches = new Array(n)
 
-Glob.prototype._finish = function () {
-  assert(this instanceof Glob)
+  this._emitQueue = []
+  this._processQueue = []
+  this.paused = false
 
-  var nou = this.nounique
-  , all = nou ? [] : {}
-
-  for (var i = 0, l = this.matches.length; i < l; i ++) {
-    var matches = this.matches[i]
-    this.log("matches[%d] =", i, matches)
-    // do like the shell, and spit out the literal glob
-    if (!matches) {
-      if (this.nonull) {
-        var literal = this.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 (this.noprocess)
+    return this
 
-  if (!nou) all = Object.keys(all)
+  if (n === 0)
+    return done()
 
-  if (!this.nosort) {
-    all = all.sort(this.nocase ? alphasorti : alphasort)
+  for (var i = 0; i < n; i ++) {
+    this._process(this.minimatch.set[i], i, false, done)
   }
 
-  if (this.mark) {
-    // at *some* point we statted all of these
-    all = all.map(this._mark, this)
+  function done () {
+    --self._processing
+    if (self._processing <= 0)
+      self._finish()
   }
-
-  this.log("emitting end", all)
-
-  this.EOF = this.found = all
-  this.emitMatch(this.EOF)
 }
 
-function alphasorti (a, b) {
-  a = a.toLowerCase()
-  b = b.toLowerCase()
-  return alphasort(a, b)
-}
+Glob.prototype._finish = function () {
+  assert(this instanceof Glob)
+  if (this.aborted)
+    return
 
-function alphasort (a, b) {
-  return a > b ? 1 : a < b ? -1 : 0
+  //console.error('FINISH', this.matches)
+  common.finish(this)
+  this.emit("end", this.found)
 }
 
 Glob.prototype._mark = function (p) {
-  var c = this.cache[p]
-  var m = p
-  if (c) {
-    var isDir = c === 2 || Array.isArray(c)
-    var slash = p.slice(-1) === '/'
-
-    if (isDir && !slash)
-      m += '/'
-    else if (!isDir && slash)
-      m = m.slice(0, -1)
-
-    if (m !== p) {
-      this.statCache[m] = this.statCache[p]
-      this.cache[m] = this.cache[p]
-    }
-  }
+  return common.mark(this, p)
+}
 
-  return m
+Glob.prototype._makeAbs = function (f) {
+  return common.makeAbs(this, f)
 }
 
 Glob.prototype.abort = function () {
@@ -277,111 +181,50 @@ Glob.prototype.abort = function () {
 }
 
 Glob.prototype.pause = function () {
-  if (this.paused) return
-  if (this.sync)
-    this.emit("error", new Error("Can't pause/resume sync glob"))
-  this.paused = true
-  this.emit("pause")
+  if (!this.paused) {
+    this.paused = true
+    this.emit("pause")
+  }
 }
 
 Glob.prototype.resume = function () {
-  if (!this.paused) return
-  if (this.sync)
-    this.emit("error", new Error("Can't pause/resume sync glob"))
-  this.paused = false
-  this.emit("resume")
-  this._processEmitQueue()
-  //process.nextTick(this.emit.bind(this, "resume"))
-}
-
-Glob.prototype.emitMatch = function (m) {
-  this.log('emitMatch', m)
-  this._emitQueue.push(m)
-  this._processEmitQueue()
-}
-
-Glob.prototype._processEmitQueue = function (m) {
-  this.log("pEQ paused=%j processing=%j m=%j", this.paused,
-           this._processingEmitQueue, m)
-  var done = false
-  while (!this._processingEmitQueue &&
-         !this.paused) {
-    this._processingEmitQueue = true
-    var m = this._emitQueue.shift()
-    this.log(">processEmitQueue", m === this.EOF ? ":EOF:" : m)
-    if (!m) {
-      this.log(">processEmitQueue, falsey m")
-      this._processingEmitQueue = false
-      break
-    }
-
-    if (m === this.EOF || !(this.mark && !this.stat)) {
-      this.log("peq: unmarked, or eof")
-      next.call(this, 0, false)
-    } else if (this.statCache[m]) {
-      var sc = this.statCache[m]
-      var exists
-      if (sc)
-        exists = sc.isDirectory() ? 2 : 1
-      this.log("peq: stat cached")
-      next.call(this, exists, exists === 2)
-    } else {
-      this.log("peq: _stat, then next")
-      this._stat(m, next)
+  if (this.paused) {
+    this.emit("resume")
+    this.paused = false
+    if (this._emitQueue.length) {
+      var eq = this._emitQueue.slice(0)
+      this._emitQueue.length = 0
+      for (var i = 0; i < eq.length; i ++) {
+        var e = eq[i]
+        this._emitMatch(e[0], e[1])
+      }
     }
-  }
-  done = true
-
-  function next(exists, isDir) {
-    this.log("next", m, exists, isDir)
-    var ev = m === this.EOF ? "end" : "match"
-
-    // "end" can only happen once.
-    assert(!this._endEmitted)
-    if (ev === "end")
-      this._endEmitted = true
-
-    if (exists) {
-      // Doesn't mean it necessarily doesn't exist, it's possible
-      // we just didn't check because we don't care that much, or
-      // this is EOF anyway.
-      if (isDir && !m.match(/\/$/)) {
-        m = m + "/"
-      } else if (!isDir && m.match(/\/$/)) {
-        m = m.replace(/\/+$/, "")
+    if (this._processQueue.length) {
+      var pq = this._processQueue.slice(0)
+      this._processQueue.length = 0
+      for (var i = 0; i < pq.length; i ++) {
+        var p = pq[i]
+        this._processing--
+        this._process(p[0], p[1], p[2], p[3])
       }
     }
-    this.log("emit", ev, m)
-    this.emit(ev, m)
-    this._processingEmitQueue = false
-    if (done && m !== this.EOF && !this.paused)
-      this._processEmitQueue()
   }
 }
 
-Glob.prototype._process = function (pattern, depth, index, cb_) {
+Glob.prototype._process = function (pattern, index, inGlobStar, cb) {
   assert(this instanceof Glob)
+  assert(typeof cb === 'function')
 
-  var cb = function cb (er, res) {
-    assert(this instanceof Glob)
-    if (this.paused) {
-      if (!this._processQueue) {
-        this._processQueue = []
-        this.once("resume", function () {
-          var q = this._processQueue
-          this._processQueue = null
-          q.forEach(function (cb) { cb() })
-        })
-      }
-      this._processQueue.push(cb_.bind(this, er, res))
-    } else {
-      cb_.call(this, er, res)
-    }
-  }.bind(this)
+  if (this.aborted)
+    return
 
-  if (this.aborted) return cb()
+  this._processing++
+  if (this.paused) {
+    this._processQueue.push([pattern, index, inGlobStar, cb])
+    return
+  }
 
-  if (depth > this.maxDepth) return cb()
+  //console.error("PROCESS %d", this._processing, pattern)
 
   // Get the first [n] parts of pattern that are all strings.
   var n = 0
@@ -395,28 +238,7 @@ Glob.prototype._process = function (pattern, depth, index, cb_) {
   switch (n) {
     // if not, then this is rather simple
     case pattern.length:
-      prefix = pattern.join("/")
-      this._stat(prefix, function (exists, isDir) {
-        // either it's there, or it isn't.
-        // nothing more to do, either way.
-        if (exists) {
-          if (prefix && isAbsolute(prefix) && !this.nomount) {
-            if (prefix.charAt(0) === "/") {
-              prefix = path.join(this.root, prefix)
-            } else {
-              prefix = path.resolve(this.root, prefix)
-            }
-          }
-
-          if (process.platform === "win32")
-            prefix = prefix.replace(/\\/g, "/")
-
-          this.matches[index] = this.matches[index] || {}
-          this.matches[index][prefix] = true
-          this.emitMatch(prefix)
-        }
-        return cb()
-      })
+      this._processSimple(pattern.join('/'), index, cb)
       return
 
     case 0:
@@ -429,318 +251,396 @@ Glob.prototype._process = function (pattern, depth, index, cb_) {
       // pattern has some string bits in the front.
       // whatever it starts with, whether that's "absolute" like /foo/bar,
       // or "relative" like "../baz"
-      prefix = pattern.slice(0, n)
-      prefix = prefix.join("/")
+      prefix = pattern.slice(0, n).join("/")
       break
   }
 
+  var remain = pattern.slice(n)
+
   // get the list of entries.
   var read
-  if (prefix === null) read = "."
+  if (prefix === null)
+    read = "."
   else if (isAbsolute(prefix) || isAbsolute(pattern.join("/"))) {
-    if (!prefix || !isAbsolute(prefix)) {
+    if (!prefix || !isAbsolute(prefix))
       prefix = "/" + prefix
-    }
+    read = prefix
+  } else
     read = prefix
 
-    // if (process.platform === "win32")
-    //   read = prefix = prefix.replace(/^[a-zA-Z]:|\\/g, "/")
+  var abs = this._makeAbs(read)
 
-    this.log('absolute: ', prefix, this.root, pattern, read)
-  } else {
-    read = prefix
-  }
+  var isGlobStar = remain[0] === minimatch.GLOBSTAR
+  if (isGlobStar)
+    this._processGlobStar(prefix, read, abs, remain, index, inGlobStar, cb)
+  else
+    this._processReaddir(prefix, read, abs, remain, index, inGlobStar, cb)
+}
 
-  this.log('readdir(%j)', read, this.cwd, this.root)
 
-  return this._readdir(read, function (er, entries) {
-    if (er) {
-      // not a directory!
-      // this means that, whatever else comes after this, it can never match
-      return cb()
+Glob.prototype._processReaddir = function (prefix, read, abs, remain, index, inGlobStar, cb) {
+  var self = this
+  this._readdir(abs, inGlobStar, function (er, entries) {
+    return self._processReaddir2(prefix, read, abs, remain, index, inGlobStar, entries, cb)
+  })
+}
+
+Glob.prototype._processReaddir2 = function (prefix, read, abs, remain, index, inGlobStar, entries, cb) {
+
+  // if the abs isn't a dir, then nothing can match!
+  if (!entries)
+    return cb()
+
+  // It will only match dot entries if it starts with a dot, or if
+  // dot is set.  Stuff like @(.foo|.bar) isn't allowed.
+  var pn = remain[0]
+  var negate = !!this.minimatch.negate
+  var rawGlob = pn._glob
+  var dotOk = this.dot || rawGlob.charAt(0) === "."
+
+  var matchedEntries = []
+  for (var i = 0; i < entries.length; i++) {
+    var e = entries[i]
+    if (e.charAt(0) !== "." || dotOk) {
+      var m
+      if (negate && !prefix) {
+        m = !e.match(pn)
+      } else {
+        m = e.match(pn)
+      }
+      if (m)
+        matchedEntries.push(e)
     }
+  }
 
-    // globstar is special
-    if (pattern[n] === minimatch.GLOBSTAR) {
-      // test without the globstar, and with every child both below
-      // and replacing the globstar.
-      var s = [ pattern.slice(0, n).concat(pattern.slice(n + 1)) ]
-      entries.forEach(function (e) {
-        if (e.charAt(0) === "." && !this.dot) return
-        // instead of the globstar
-        s.push(pattern.slice(0, n).concat(e).concat(pattern.slice(n + 1)))
-        // below the globstar
-        s.push(pattern.slice(0, n).concat(e).concat(pattern.slice(n)))
-      }, this)
-
-      s = s.filter(function (pattern) {
-        var key = gsKey(pattern)
-        var seen = !this._globstars[key]
-        this._globstars[key] = true
-        return seen
-      }, this)
-
-      if (!s.length)
-        return cb()
-
-      // now asyncForEach over this
-      var l = s.length
-      , errState = null
-      s.forEach(function (gsPattern) {
-        this._process(gsPattern, depth + 1, index, function (er) {
-          if (errState) return
-          if (er) return cb(errState = er)
-          if (--l <= 0) return cb()
-        })
-      }, this)
+  //console.error('prd2', prefix, entries, remain[0]._glob, matchedEntries)
+
+  var len = matchedEntries.length
+  // If there are no matched entries, then nothing matches.
+  if (len === 0)
+    return cb()
+
+  // if this is the last remaining pattern bit, then no need for
+  // an additional stat *unless* the user has specified mark or
+  // stat explicitly.  We know they exist, since readdir returned
+  // them.
+
+  if (remain.length === 1 && !this.mark && !this.stat) {
+    if (!this.matches[index])
+      this.matches[index] = Object.create(null)
+
+    for (var i = 0; i < len; i ++) {
+      var e = matchedEntries[i]
+      if (prefix) {
+        if (prefix !== "/")
+          e = prefix + "/" + e
+        else
+          e = prefix + e
+      }
 
-      return
+      if (e.charAt(0) === "/" && !this.nomount) {
+        e = path.join(this.root, e)
+      }
+      this._emitMatch(index, e)
     }
+    // This was the last one, and no stats were needed
+    return cb()
+  }
 
-    // not a globstar
-    // It will only match dot entries if it starts with a dot, or if
-    // dot is set.  Stuff like @(.foo|.bar) isn't allowed.
-    var pn = pattern[n]
-    var negate = !!this.minimatch.negate;
-    var rawGlob = pattern[n]._glob
-    , dotOk = this.dot || rawGlob.charAt(0) === "."
-
-    entries = entries.filter(function (e) {
-      if (e.charAt(0) !== "." || dotOk) {
-        if (negate && n === 0) {
-          return !e.match(pattern[n]);
-        } else {
-          return e.match(pattern[n]);
-        }
-      }
+  // now test all matched entries as stand-ins for that part
+  // of the pattern.
+  remain.shift()
+  for (var i = 0; i < len; i ++) {
+    var e = matchedEntries[i]
+    var newPattern
+    if (prefix) {
+      if (prefix !== "/")
+        e = prefix + "/" + e
+      else
+        e = prefix + e
+    }
+    this._process([e].concat(remain), index, inGlobStar, cb)
+  }
+  cb()
+}
 
-      return null;
-    })
+Glob.prototype._emitMatch = function (index, e) {
+  if (this.aborted)
+    return
 
-    // If n === pattern.length - 1, then there's no need for the extra stat
-    // *unless* the user has specified "mark" or "stat" explicitly.
-    // We know that they exist, since the readdir returned them.
-    if (n === pattern.length - 1 &&
-        !this.mark &&
-        !this.stat) {
-      entries.forEach(function (e) {
-        if (prefix) {
-          if (prefix !== "/") e = prefix + "/" + e
-          else e = prefix + e
-        }
-        if (e.charAt(0) === "/" && !this.nomount) {
-          e = path.join(this.root, e)
-        }
-
-        if (process.platform === "win32")
-          e = e.replace(/\\/g, "/")
-
-        this.matches[index] = this.matches[index] || {}
-        this.matches[index][e] = true
-        this.emitMatch(e)
-      }, this)
-      return cb.call(this)
+  if (!this.matches[index][e]) {
+    if (this.paused) {
+      this._emitQueue.push([index, e])
+      return
     }
 
+    if (this.nodir) {
+      var c = this.cache[this._makeAbs(e)]
+      if (c === 'DIR' || Array.isArray(c))
+        return
+    }
 
-    // now test all the remaining entries as stand-ins for that part
-    // of the pattern.
-    var l = entries.length
-    , errState = null
-    if (l === 0) return cb() // no matches possible
-    entries.forEach(function (e) {
-      var p = pattern.slice(0, n).concat(e).concat(pattern.slice(n + 1))
-      this._process(p, depth + 1, index, function (er) {
-        if (errState) return
-        if (er) return cb(errState = er)
-        if (--l === 0) return cb.call(this)
-      })
-    }, this)
-  })
+    this.matches[index][e] = true
+    if (!this.stat && !this.mark)
+      return this.emit("match", e)
 
+    var self = this
+    this._stat(this._makeAbs(e), function (er, c, st) {
+      self.emit("stat", e, st)
+      self.emit("match", e)
+    })
+  }
 }
 
-function gsKey (pattern) {
-  return '**' + pattern.map(function (p) {
-    return (p === minimatch.GLOBSTAR) ? '**' : (''+p)
-  }).join('/')
-}
+Glob.prototype._readdirInGlobStar = function (abs, cb) {
+  if (this.aborted)
+    return
 
-Glob.prototype._stat = function (f, cb) {
-  assert(this instanceof Glob)
-  var abs = f
-  if (f.charAt(0) === "/") {
-    abs = path.join(this.root, f)
-  } else if (this.changedCwd) {
-    abs = path.resolve(this.cwd, f)
-  }
+  var lstatkey = "lstat\0" + abs
+  var self = this
+  var lstatcb = inflight(lstatkey, lstatcb_)
 
-  if (f.length > this.maxLength) {
-    var er = new Error("Path name too long")
-    er.code = "ENAMETOOLONG"
-    er.path = f
-    return this._afterStat(f, abs, cb, er)
-  }
+  if (lstatcb)
+    fs.lstat(abs, lstatcb)
 
-  this.log('stat', [this.cwd, f, '=', abs])
+  function lstatcb_ (er, lstat) {
+    if (er)
+      return cb()
 
-  if (!this.stat && this.cache.hasOwnProperty(f)) {
-    var exists = this.cache[f]
-    , isDir = exists && (Array.isArray(exists) || exists === 2)
-    if (this.sync) return cb.call(this, !!exists, isDir)
-    return process.nextTick(cb.bind(this, !!exists, isDir))
-  }
+    var isSym = lstat.isSymbolicLink()
+    self.symlinks[abs] = isSym
 
-  var stat = this.statCache[abs]
-  if (this.sync || stat) {
-    var er
-    try {
-      stat = fs.statSync(abs)
-    } catch (e) {
-      er = e
-    }
-    this._afterStat(f, abs, cb, er, stat)
-  } else {
-    fs.stat(abs, this._afterStat.bind(this, f, abs, cb))
+    // If it's not a symlink or a dir, then it's definitely a regular file.
+    // don't bother doing a readdir in that case.
+    if (!isSym && !lstat.isDirectory()) {
+      self.cache[abs] = 'FILE'
+      cb()
+    } else
+      self._readdir(abs, false, cb)
   }
 }
 
-Glob.prototype._afterStat = function (f, abs, cb, er, stat) {
-  var exists
-  assert(this instanceof Glob)
+Glob.prototype._readdir = function (abs, inGlobStar, cb) {
+  if (this.aborted)
+    return
 
-  if (abs.slice(-1) === "/" && stat && !stat.isDirectory()) {
-    this.log("should be ENOTDIR, fake it")
+  cb = inflight("readdir\0"+abs+"\0"+inGlobStar, cb)
+  if (!cb)
+    return
 
-    er = new Error("ENOTDIR, not a directory '" + abs + "'")
-    er.path = abs
-    er.code = "ENOTDIR"
-    stat = null
-  }
+  //console.error("RD %j %j", +inGlobStar, abs)
+  if (inGlobStar && !ownProp(this.symlinks, abs))
+    return this._readdirInGlobStar(abs, cb)
 
-  var emit = !this.statCache[abs]
-  this.statCache[abs] = stat
+  if (ownProp(this.cache, abs)) {
+    var c = this.cache[abs]
+    if (!c || c === 'FILE')
+      return cb()
 
-  if (er || !stat) {
-    exists = false
-  } else {
-    exists = stat.isDirectory() ? 2 : 1
-    if (emit)
-      this.emit('stat', f, stat)
+    if (Array.isArray(c))
+      return cb(null, c)
   }
-  this.cache[f] = this.cache[f] || exists
-  cb.call(this, !!exists, exists === 2)
-}
 
-Glob.prototype._readdir = function (f, cb) {
-  assert(this instanceof Glob)
-  var abs = f
-  if (f.charAt(0) === "/") {
-    abs = path.join(this.root, f)
-  } else if (isAbsolute(f)) {
-    abs = f
-  } else if (this.changedCwd) {
-    abs = path.resolve(this.cwd, f)
-  }
+  var self = this
+  fs.readdir(abs, readdirCb(this, abs, cb))
+}
 
-  if (f.length > this.maxLength) {
-    var er = new Error("Path name too long")
-    er.code = "ENAMETOOLONG"
-    er.path = f
-    return this._afterReaddir(f, abs, cb, er)
+function readdirCb (self, abs, cb) {
+  return function (er, entries) {
+    if (er)
+      self._readdirError(abs, er, cb)
+    else
+      self._readdirEntries(abs, entries, cb)
   }
+}
 
-  this.log('readdir', [this.cwd, f, abs])
-  if (this.cache.hasOwnProperty(f)) {
-    var c = this.cache[f]
-    if (Array.isArray(c)) {
-      if (this.sync) return cb.call(this, null, c)
-      return process.nextTick(cb.bind(this, null, c))
-    }
-
-    if (!c || c === 1) {
-      // either ENOENT or ENOTDIR
-      var code = c ? "ENOTDIR" : "ENOENT"
-      , er = new Error((c ? "Not a directory" : "Not found") + ": " + f)
-      er.path = f
-      er.code = code
-      this.log(f, er)
-      if (this.sync) return cb.call(this, er)
-      return process.nextTick(cb.bind(this, er))
-    }
-
-    // at this point, c === 2, meaning it's a dir, but we haven't
-    // had to read it yet, or c === true, meaning it's *something*
-    // but we don't have any idea what.  Need to read it, either way.
-  }
+Glob.prototype._readdirEntries = function (abs, entries, cb) {
+  if (this.aborted)
+    return
 
-  if (this.sync) {
-    var er, entries
-    try {
-      entries = fs.readdirSync(abs)
-    } catch (e) {
-      er = e
+  // if we haven't asked to stat everything, then just
+  // assume that everything in there exists, so we can avoid
+  // having to stat it a second time.
+  if (!this.mark && !this.stat) {
+    for (var i = 0; i < entries.length; i ++) {
+      var e = entries[i]
+      if (abs === "/")
+        e = abs + e
+      else
+        e = abs + "/" + e
+      this.cache[e] = true
     }
-    return this._afterReaddir(f, abs, cb, er, entries)
   }
 
-  fs.readdir(abs, this._afterReaddir.bind(this, f, abs, cb))
+  this.cache[abs] = entries
+  return cb(null, entries)
 }
 
-Glob.prototype._afterReaddir = function (f, abs, cb, er, entries) {
-  assert(this instanceof Glob)
-  if (entries && !er) {
-    this.cache[f] = entries
-    // if we haven't asked to stat everything for suresies, then just
-    // assume that everything in there exists, so we can avoid
-    // having to stat it a second time.  This also gets us one step
-    // further into ELOOP territory.
-    if (!this.mark && !this.stat) {
-      entries.forEach(function (e) {
-        if (f === "/") e = f + e
-        else e = f + "/" + e
-        this.cache[e] = true
-      }, this)
-    }
-
-    return cb.call(this, er, entries)
-  }
+Glob.prototype._readdirError = function (f, er, cb) {
+  if (this.aborted)
+    return
 
-  // now handle errors, and cache the information
-  if (er) switch (er.code) {
+  // handle errors, and cache the information
+  switch (er.code) {
     case "ENOTDIR": // totally normal. means it *does* exist.
-      this.cache[f] = 1
-      return cb.call(this, er)
+      this.cache[f] = 'FILE'
+      break
+
     case "ENOENT": // not terribly unusual
     case "ELOOP":
     case "ENAMETOOLONG":
     case "UNKNOWN":
       this.cache[f] = false
-      return cb.call(this, er)
+      break
+
     default: // some unusual error.  Treat as failure.
       this.cache[f] = false
-      if (this.strict) this.emit("error", er)
+      if (this.strict) return this.emit("error", er)
       if (!this.silent) console.error("glob error", er)
-      return cb.call(this, er)
+      break
   }
+  return cb()
 }
 
-var isAbsolute = process.platform === "win32" ? absWin : absUnix
+Glob.prototype._processGlobStar = function (prefix, read, abs, remain, index, inGlobStar, cb) {
+  var self = this
+  this._readdir(abs, inGlobStar, function (er, entries) {
+    self._processGlobStar2(prefix, read, abs, remain, index, inGlobStar, entries, cb)
+  })
+}
+
+
+Glob.prototype._processGlobStar2 = function (prefix, read, abs, remain, index, inGlobStar, entries, cb) {
+  //console.error("pgs2", prefix, remain[0], entries)
+
+  // no entries means not a dir, so it can never have matches
+  // foo.txt/** doesn't match foo.txt
+  if (!entries)
+    return cb()
+
+  // test without the globstar, and with every child both below
+  // and replacing the globstar.
+  var remainWithoutGlobStar = remain.slice(1)
+  var gspref = prefix ? [ prefix ] : []
+  var noGlobStar = gspref.concat(remainWithoutGlobStar)
+
+  // the noGlobStar pattern exits the inGlobStar state
+  this._process(noGlobStar, index, false, cb)
 
-function absWin (p) {
-  if (absUnix(p)) return true
-  // pull off the device/UNC bit from a windows path.
-  // from node's lib/path.js
-  var splitDeviceRe =
-      /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/
-    , result = splitDeviceRe.exec(p)
-    , device = result[1] || ''
-    , isUnc = device && device.charAt(1) !== ':'
-    , isAbsolute = !!result[2] || isUnc // UNC paths are always absolute
+  var isSym = this.symlinks[abs]
+  var len = entries.length
 
-  return isAbsolute
+  // If it's a symlink, and we're in a globstar, then stop
+  if (isSym && inGlobStar)
+    return cb()
+
+  for (var i = 0; i < len; i++) {
+    var e = entries[i]
+    if (e.charAt(0) === "." && !this.dot)
+      continue
+
+    // these two cases enter the inGlobStar state
+    var instead = gspref.concat(entries[i], remainWithoutGlobStar)
+    this._process(instead, index, true, cb)
+
+    var below = gspref.concat(entries[i], remain)
+    this._process(below, index, true, cb)
+  }
+
+  cb()
 }
 
-function absUnix (p) {
-  return p.charAt(0) === "/" || p === ""
+Glob.prototype._processSimple = function (prefix, index, cb) {
+  // XXX review this.  Shouldn't it be doing the mounting etc
+  // before doing stat?  kinda weird?
+  var self = this
+  this._stat(prefix, function (er, exists) {
+    self._processSimple2(prefix, index, er, exists, cb)
+  })
+}
+Glob.prototype._processSimple2 = function (prefix, index, er, exists, cb) {
+
+  //console.error("ps2", prefix, exists)
+
+  if (!this.matches[index])
+    this.matches[index] = Object.create(null)
+
+  // If it doesn't exist, then just mark the lack of results
+  if (!exists)
+    return cb()
+
+  if (prefix && isAbsolute(prefix) && !this.nomount) {
+    if (prefix.charAt(0) === "/") {
+      prefix = path.join(this.root, prefix)
+    } else {
+      prefix = path.resolve(this.root, prefix)
+    }
+  }
+
+  if (process.platform === "win32")
+    prefix = prefix.replace(/\\/g, "/")
+
+  // Mark this as a match
+  this._emitMatch(index, prefix)
+  cb()
+}
+
+// Returns either 'DIR', 'FILE', or false
+Glob.prototype._stat = function (f, cb) {
+  var abs = f
+  if (f.charAt(0) === "/")
+    abs = path.join(this.root, f)
+  else if (this.changedCwd)
+    abs = path.resolve(this.cwd, f)
+
+
+  if (f.length > this.maxLength)
+    return cb()
+
+  if (!this.stat && ownProp(this.cache, f)) {
+    var c = this.cache[f]
+
+    if (Array.isArray(c))
+      c = 'DIR'
+
+    // It exists, but not how we need it
+    if (abs.slice(-1) === "/" && c !== 'DIR')
+      return cb()
+
+    return cb(null, c)
+  }
+
+  var exists
+  var stat = this.statCache[abs]
+  if (stat !== undefined) {
+    if (stat === false)
+      return cb(null, stat)
+    else
+      return cb(null, stat.isDirectory() ? 'DIR' : 'FILE', stat)
+  }
+
+  var self = this
+  var statcb = inflight("stat\0" + abs, statcb_)
+  if (statcb)
+    fs.stat(abs, statcb)
+
+  function statcb_ (er, stat) {
+    self._stat2(f, abs, er, stat, cb)
+  }
+}
+
+Glob.prototype._stat2 = function (f, abs, er, stat, cb) {
+  if (er) {
+    this.statCache[abs] = false
+    return cb()
+  }
+
+  this.statCache[abs] = stat
+
+  if (abs.slice(-1) === "/" && !stat.isDirectory())
+    return cb(null, false, stat)
+
+  var c = stat.isDirectory() ? 'DIR' : 'FILE'
+  this.cache[f] = this.cache[f] || c
+  return cb(null, c, stat)
 }