fsevents 1.2.0 → 1.2.2

package/node_modules/ignore-walk/index.js

@@ -0,0 +1,265 @@
+'use strict'
+
+const fs = require('fs')
+const path = require('path')
+const EE = require('events').EventEmitter
+const Minimatch = require('minimatch').Minimatch
+
+class Walker extends EE {
+  constructor (opts) {
+    opts = opts || {}
+    super(opts)
+    this.path = opts.path || process.cwd()
+    this.basename = path.basename(this.path)
+    this.ignoreFiles = opts.ignoreFiles || [ '.ignore' ]
+    this.ignoreRules = {}
+    this.parent = opts.parent || null
+    this.includeEmpty = !!opts.includeEmpty
+    this.root = this.parent ? this.parent.root : this.path
+    this.follow = !!opts.follow
+    this.result = this.parent ? this.parent.result : []
+    this.entries = null
+    this.sawError = false
+  }
+
+  sort (a, b) {
+    return a.localeCompare(b)
+  }
+
+  emit (ev, data) {
+    let ret = false
+    if (!(this.sawError && ev === 'error')) {
+      if (ev === 'error')
+        this.sawError = true
+      else if (ev === 'done' && !this.parent)
+        data = data.sort(this.sort)
+      if (ev === 'error' && this.parent)
+        ret = this.parent.emit('error', data)
+      else
+        ret = super.emit(ev, data)
+    }
+    return ret
+  }
+
+  start () {
+    fs.readdir(this.path, (er, entries) =>
+      er ? this.emit('error', er) : this.onReaddir(entries))
+    return this
+  }
+
+  isIgnoreFile (e) {
+    return e !== "." &&
+      e !== ".." &&
+      -1 !== this.ignoreFiles.indexOf(e)
+  }
+
+  onReaddir (entries) {
+    this.entries = entries
+    if (entries.length === 0) {
+      if (this.includeEmpty)
+        this.result.push(this.path.substr(this.root.length + 1))
+      this.emit('done', this.result)
+    } else {
+      const hasIg = this.entries.some(e =>
+        this.isIgnoreFile(e))
+
+      if (hasIg)
+        this.addIgnoreFiles()
+      else
+        this.filterEntries()
+    }
+  }
+
+  addIgnoreFiles () {
+    const newIg = this.entries
+      .filter(e => this.isIgnoreFile(e))
+
+    let igCount = newIg.length
+    const then = _ => {
+      if (--igCount === 0)
+        this.filterEntries()
+    }
+
+    newIg.forEach(e => this.addIgnoreFile(e, then))
+  }
+
+  addIgnoreFile (file, then) {
+    const ig = path.resolve(this.path, file)
+    fs.readFile(ig, 'utf8', (er, data) =>
+      er ? this.emit('error', er) : this.onReadIgnoreFile(file, data, then))
+  }
+
+  onReadIgnoreFile (file, data, then) {
+    const mmopt = {
+      matchBase: true,
+      dot: true,
+      flipNegate: true,
+      nocase: true
+    }
+    const rules = data.split(/\r?\n/)
+      .filter(line => !/^#|^$/.test(line.trim()))
+      .map(r => new Minimatch(r, mmopt))
+
+    this.ignoreRules[file] = rules
+
+    then()
+  }
+
+  filterEntries () {
+    // at this point we either have ignore rules, or just inheriting
+    // this exclusion is at the point where we know the list of
+    // entries in the dir, but don't know what they are.  since
+    // some of them *might* be directories, we have to run the
+    // match in dir-mode as well, so that we'll pick up partials
+    // of files that will be included later.  Anything included
+    // at this point will be checked again later once we know
+    // what it is.
+    const filtered = this.entries.map(entry => {
+      // at this point, we don't know if it's a dir or not.
+      const passFile = this.filterEntry(entry)
+      const passDir = this.filterEntry(entry, true)
+      return (passFile || passDir) ? [entry, passFile, passDir] : false
+    }).filter(e => e)
+
+    // now we stat them all
+    // if it's a dir, and passes as a dir, then recurse
+    // if it's not a dir, but passes as a file, add to set
+    let entryCount = filtered.length
+    if (entryCount === 0) {
+      this.emit('done', this.result)
+    } else {
+      const then = _ => {
+        if (-- entryCount === 0)
+          this.emit('done', this.result)
+      }
+      filtered.forEach(filt => {
+        const entry = filt[0]
+        const file = filt[1]
+        const dir = filt[2]
+        this.stat(entry, file, dir, then)
+      })
+    }
+  }
+
+  onstat (st, entry, file, dir, then) {
+    const abs = this.path + '/' + entry
+    if (!st.isDirectory()) {
+      if (file)
+        this.result.push(abs.substr(this.root.length + 1))
+      then()
+    } else {
+      // is a directory
+      if (dir)
+        this.walker(entry, then)
+      else
+        then()
+    }
+  }
+
+  stat (entry, file, dir, then) {
+    const abs = this.path + '/' + entry
+    fs[this.follow ? 'stat' : 'lstat'](abs, (er, st) => {
+      if (er)
+        this.emit('error', er)
+      else
+        this.onstat(st, entry, file, dir, then)
+    })
+  }
+
+  walkerOpt (entry) {
+    return {
+      path: this.path + '/' + entry,
+      parent: this,
+      ignoreFiles: this.ignoreFiles,
+      follow: this.follow,
+      includeEmpty: this.includeEmpty
+    }
+  }
+
+  walker (entry, then) {
+    new Walker(this.walkerOpt(entry)).on('done', then).start()
+  }
+
+  filterEntry (entry, partial) {
+    let included = true
+
+    // this = /a/b/c
+    // entry = d
+    // parent /a/b sees c/d
+    if (this.parent && this.parent.filterEntry) {
+      var pt = this.basename + "/" + entry
+      included = this.parent.filterEntry(pt, partial)
+    }
+
+    this.ignoreFiles.forEach(f => {
+      if (this.ignoreRules[f]) {
+        this.ignoreRules[f].forEach(rule => {
+          // negation means inclusion
+          // so if it's negated, and already included, no need to check
+          // likewise if it's neither negated nor included
+          if (rule.negate !== included) {
+            // first, match against /foo/bar
+            // then, against foo/bar
+            // then, in the case of partials, match with a /
+            const match = rule.match('/' + entry) ||
+              rule.match(entry) ||
+              (!!partial && (
+                rule.match('/' + entry + '/') ||
+                rule.match(entry + '/'))) ||
+              (!!partial && rule.negate && (
+                rule.match('/' + entry, true) ||
+                rule.match(entry, true)))
+
+            if (match)
+              included = rule.negate
+          }
+        })
+      }
+    })
+
+    return included
+  }
+}
+
+class WalkerSync extends Walker {
+  constructor (opt) {
+    super(opt)
+  }
+
+  start () {
+    this.onReaddir(fs.readdirSync(this.path))
+    return this
+  }
+
+  addIgnoreFile (file, then) {
+    const ig = path.resolve(this.path, file)
+    this.onReadIgnoreFile(file, fs.readFileSync(ig, 'utf8'), then)
+  }
+
+  stat (entry, file, dir, then) {
+    const abs = this.path + '/' + entry
+    const st = fs[this.follow ? 'statSync' : 'lstatSync'](abs)
+    this.onstat(st, entry, file, dir, then)
+  }
+
+  walker (entry, then) {
+    new WalkerSync(this.walkerOpt(entry)).start()
+    then()
+  }
+}
+
+const walk = (options, callback) => {
+  const p = new Promise((resolve, reject) => {
+    new Walker(options).on('done', resolve).on('error', reject).start()
+  })
+  return callback ? p.then(res => callback(null, res), callback) : p
+}
+
+const walkSync = options => {
+  return new WalkerSync(options).start().result
+}
+
+module.exports = walk
+walk.sync = walkSync
+walk.Walker = Walker
+walk.WalkerSync = WalkerSync

package/node_modules/ignore-walk/package.json

@@ -0,0 +1,71 @@
+{
+  "_from": "ignore-walk@^3.0.1",
+  "_id": "ignore-walk@3.0.1",
+  "_inBundle": false,
+  "_integrity": "sha512-DTVlMx3IYPe0/JJcYP7Gxg7ttZZu3IInhuEhbchuqneY9wWe5Ojy2mXLBaQFUQmo0AW2r3qG7m1mg86js+gnlQ==",
+  "_location": "/ignore-walk",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "ignore-walk@^3.0.1",
+    "name": "ignore-walk",
+    "escapedName": "ignore-walk",
+    "rawSpec": "^3.0.1",
+    "saveSpec": null,
+    "fetchSpec": "^3.0.1"
+  },
+  "_requiredBy": [
+    "/npm-packlist"
+  ],
+  "_resolved": "https://registry.npmjs.org/ignore-walk/-/ignore-walk-3.0.1.tgz",
+  "_shasum": "a83e62e7d272ac0e3b551aaa82831a19b69f82f8",
+  "_spec": "ignore-walk@^3.0.1",
+  "_where": "/Users/eshanker/Code/fsevents/node_modules/npm-packlist",
+  "author": {
+    "name": "Isaac Z. Schlueter",
+    "email": "i@izs.me",
+    "url": "http://blog.izs.me/"
+  },
+  "bugs": {
+    "url": "https://github.com/isaacs/ignore-walk/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "minimatch": "^3.0.4"
+  },
+  "deprecated": false,
+  "description": "Nested/recursive `.gitignore`/`.npmignore` parsing and filtering.",
+  "devDependencies": {
+    "mkdirp": "^0.5.1",
+    "mutate-fs": "^1.1.0",
+    "rimraf": "^2.6.1",
+    "tap": "^10.7.2"
+  },
+  "files": [
+    "index.js"
+  ],
+  "homepage": "https://github.com/isaacs/ignore-walk#readme",
+  "keywords": [
+    "ignorefile",
+    "ignore",
+    "file",
+    ".gitignore",
+    ".npmignore",
+    "glob"
+  ],
+  "license": "ISC",
+  "main": "index.js",
+  "name": "ignore-walk",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/isaacs/ignore-walk.git"
+  },
+  "scripts": {
+    "postpublish": "git push origin --all; git push origin --tags",
+    "postversion": "npm publish",
+    "preversion": "npm test",
+    "test": "tap test/*.js --100"
+  },
+  "version": "3.0.1"
+}

package/node_modules/inflight/package.json

@@ -1,30 +1,27 @@
 {
-  "_args": [
-    [
-      "inflight@1.0.6",
-      "/Users/eshanker/Code/fsevents"
-    ]
-  ],
-  "_from": "inflight@1.0.6",
+  "_from": "inflight@^1.0.4",
   "_id": "inflight@1.0.6",
   "_inBundle": false,
   "_integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=",
   "_location": "/inflight",
   "_phantomChildren": {},
   "_requested": {
-    "type": "version",
+    "type": "range",
     "registry": true,
-    "raw": "inflight@1.0.6",
+    "raw": "inflight@^1.0.4",
     "name": "inflight",
     "escapedName": "inflight",
-    "rawSpec": "1.0.6",
+    "rawSpec": "^1.0.4",
     "saveSpec": null,
-    "fetchSpec": "1.0.6"
+    "fetchSpec": "^1.0.4"
   },
-  "_requiredBy": [],
+  "_requiredBy": [
+    "/glob"
+  ],
   "_resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
-  "_spec": "1.0.6",
-  "_where": "/Users/eshanker/Code/fsevents",
+  "_shasum": "49bd6331d7d02d0c09bc910a1075ba8165b56df9",
+  "_spec": "inflight@^1.0.4",
+  "_where": "/Users/eshanker/Code/fsevents/node_modules/glob",
   "author": {
     "name": "Isaac Z. Schlueter",
     "email": "i@izs.me",
@@ -33,10 +30,12 @@
   "bugs": {
     "url": "https://github.com/isaacs/inflight/issues"
   },
+  "bundleDependencies": false,
   "dependencies": {
     "once": "^1.3.0",
     "wrappy": "1"
   },
+  "deprecated": false,
   "description": "Add callbacks to requests in flight to avoid async duplication",
   "devDependencies": {
     "tap": "^7.1.2"

package/node_modules/inherits/package.json

@@ -1,34 +1,36 @@
 {
-  "_args": [
-    [
-      "inherits@2.0.3",
-      "/Users/eshanker/Code/fsevents"
-    ]
-  ],
-  "_from": "inherits@2.0.3",
+  "_from": "inherits@~2.0.3",
   "_id": "inherits@2.0.3",
   "_inBundle": false,
   "_integrity": "sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4=",
   "_location": "/inherits",
   "_phantomChildren": {},
   "_requested": {
-    "type": "version",
+    "type": "range",
     "registry": true,
-    "raw": "inherits@2.0.3",
+    "raw": "inherits@~2.0.3",
     "name": "inherits",
     "escapedName": "inherits",
-    "rawSpec": "2.0.3",
+    "rawSpec": "~2.0.3",
     "saveSpec": null,
-    "fetchSpec": "2.0.3"
+    "fetchSpec": "~2.0.3"
   },
-  "_requiredBy": [],
+  "_requiredBy": [
+    "/glob",
+    "/readable-stream",
+    "/tap",
+    "/tap/glob"
+  ],
   "_resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz",
-  "_spec": "2.0.3",
-  "_where": "/Users/eshanker/Code/fsevents",
+  "_shasum": "633c2c83e3da42a502f52466022480f4208261de",
+  "_spec": "inherits@~2.0.3",
+  "_where": "/Users/eshanker/Code/fsevents/node_modules/readable-stream",
   "browser": "./inherits_browser.js",
   "bugs": {
     "url": "https://github.com/isaacs/inherits/issues"
   },
+  "bundleDependencies": false,
+  "deprecated": false,
   "description": "Browser-friendly inheritance fully compatible with standard node.js inherits()",
   "devDependencies": {
     "tap": "^7.1.0"

package/node_modules/ini/ini.js

@@ -1,17 +1,18 @@
-
 exports.parse = exports.decode = decode
+
 exports.stringify = exports.encode = encode
 
 exports.safe = safe
 exports.unsafe = unsafe
 
-var eol = process.platform === "win32" ? "\r\n" : "\n"
+var eol = typeof process !== 'undefined' &&
+  process.platform === 'win32' ? '\r\n' : '\n'
 
 function encode (obj, opt) {
   var children = []
-    , out = ""
+  var out = ''
 
-  if (typeof opt === "string") {
+  if (typeof opt === 'string') {
     opt = {
       section: opt,
       whitespace: false
@@ -21,16 +22,15 @@ function encode (obj, opt) {
     opt.whitespace = opt.whitespace === true
   }
 
-  var separator = opt.whitespace ? " = " : "="
+  var separator = opt.whitespace ? ' = ' : '='
 
   Object.keys(obj).forEach(function (k, _, __) {
     var val = obj[k]
     if (val && Array.isArray(val)) {
-        val.forEach(function(item) {
-            out += safe(k + "[]") + separator + safe(item) + "\n"
-        })
-    }
-    else if (val && typeof val === "object") {
+      val.forEach(function (item) {
+        out += safe(k + '[]') + separator + safe(item) + '\n'
+      })
+    } else if (val && typeof val === 'object') {
       children.push(k)
     } else {
       out += safe(k) + separator + safe(val) + eol
@@ -38,12 +38,12 @@ function encode (obj, opt) {
   })
 
   if (opt.section && out.length) {
-    out = "[" + safe(opt.section) + "]" + eol + out
+    out = '[' + safe(opt.section) + ']' + eol + out
   }
 
   children.forEach(function (k, _, __) {
     var nk = dotSplit(k).join('\\.')
-    var section = (opt.section ? opt.section + "." : "") + nk
+    var section = (opt.section ? opt.section + '.' : '') + nk
     var child = encode(obj[k], {
       section: section,
       whitespace: opt.whitespace
@@ -59,22 +59,20 @@ function encode (obj, opt) {
 
 function dotSplit (str) {
   return str.replace(/\1/g, '\u0002LITERAL\\1LITERAL\u0002')
-         .replace(/\\\./g, '\u0001')
-         .split(/\./).map(function (part) {
-           return part.replace(/\1/g, '\\.')
-                  .replace(/\2LITERAL\\1LITERAL\2/g, '\u0001')
-        })
+    .replace(/\\\./g, '\u0001')
+    .split(/\./).map(function (part) {
+      return part.replace(/\1/g, '\\.')
+      .replace(/\2LITERAL\\1LITERAL\2/g, '\u0001')
+    })
 }
 
 function decode (str) {
   var out = {}
-    , p = out
-    , section = null
-    , state = "START"
-           // section     |key = value
-    , re = /^\[([^\]]*)\]$|^([^=]+)(=(.*))?$/i
-    , lines = str.split(/[\r\n]+/g)
-    , section = null
+  var p = out
+  var section = null
+  //          section     |key      = value
+  var re = /^\[([^\]]*)\]$|^([^=]+)(=(.*))?$/i
+  var lines = str.split(/[\r\n]+/g)
 
   lines.forEach(function (line, _, __) {
     if (!line || line.match(/^\s*[;#]/)) return
@@ -86,7 +84,7 @@ function decode (str) {
       return
     }
     var key = unsafe(match[2])
-      , value = match[3] ? unsafe((match[4] || "")) : true
+    var value = match[3] ? unsafe(match[4]) : true
     switch (value) {
       case 'true':
       case 'false':
@@ -94,22 +92,20 @@ function decode (str) {
     }
 
     // Convert keys with '[]' suffix to an array
-    if (key.length > 2 && key.slice(-2) === "[]") {
-        key = key.substring(0, key.length - 2)
-        if (!p[key]) {
-          p[key] = []
-        }
-        else if (!Array.isArray(p[key])) {
-          p[key] = [p[key]]
-        }
+    if (key.length > 2 && key.slice(-2) === '[]') {
+      key = key.substring(0, key.length - 2)
+      if (!p[key]) {
+        p[key] = []
+      } else if (!Array.isArray(p[key])) {
+        p[key] = [p[key]]
+      }
     }
 
     // safeguard against resetting a previously defined
     // array by accidentally forgetting the brackets
     if (Array.isArray(p[key])) {
       p[key].push(value)
-    }
-    else {
+    } else {
       p[key] = value
     }
   })
@@ -117,18 +113,24 @@ function decode (str) {
   // {a:{y:1},"a.b":{x:2}} --> {a:{y:1,b:{x:2}}}
   // use a filter to return the keys that have to be deleted.
   Object.keys(out).filter(function (k, _, __) {
-    if (!out[k] || typeof out[k] !== "object" || Array.isArray(out[k])) return false
+    if (!out[k] ||
+      typeof out[k] !== 'object' ||
+      Array.isArray(out[k])) {
+      return false
+    }
     // see if the parent section is also an object.
     // if so, add it to that, and mark this one for deletion
     var parts = dotSplit(k)
-      , p = out
-      , l = parts.pop()
-      , nl = l.replace(/\\\./g, '.')
+    var p = out
+    var l = parts.pop()
+    var nl = l.replace(/\\\./g, '.')
     parts.forEach(function (part, _, __) {
-      if (!p[part] || typeof p[part] !== "object") p[part] = {}
+      if (!p[part] || typeof p[part] !== 'object') p[part] = {}
       p = p[part]
     })
-    if (p === out && nl === l) return false
+    if (p === out && nl === l) {
+      return false
+    }
     p[nl] = out[k]
     return true
   }).forEach(function (del, _, __) {
@@ -139,52 +141,54 @@ function decode (str) {
 }
 
 function isQuoted (val) {
-  return (val.charAt(0) === "\"" && val.slice(-1) === "\"")
-         || (val.charAt(0) === "'" && val.slice(-1) === "'")
+  return (val.charAt(0) === '"' && val.slice(-1) === '"') ||
+    (val.charAt(0) === "'" && val.slice(-1) === "'")
 }
 
 function safe (val) {
-  return ( typeof val !== "string"
-         || val.match(/[=\r\n]/)
-         || val.match(/^\[/)
-         || (val.length > 1
-             && isQuoted(val))
-         || val !== val.trim() )
-         ? JSON.stringify(val)
-         : val.replace(/;/g, '\\;').replace(/#/g, "\\#")
+  return (typeof val !== 'string' ||
+    val.match(/[=\r\n]/) ||
+    val.match(/^\[/) ||
+    (val.length > 1 &&
+     isQuoted(val)) ||
+    val !== val.trim())
+      ? JSON.stringify(val)
+      : val.replace(/;/g, '\\;').replace(/#/g, '\\#')
 }
 
 function unsafe (val, doUnesc) {
-  val = (val || "").trim()
+  val = (val || '').trim()
   if (isQuoted(val)) {
     // remove the single quotes before calling JSON.parse
     if (val.charAt(0) === "'") {
-      val = val.substr(1, val.length - 2);
+      val = val.substr(1, val.length - 2)
     }
     try { val = JSON.parse(val) } catch (_) {}
   } else {
     // walk the val to find the first not-escaped ; character
     var esc = false
-    var unesc = "";
+    var unesc = ''
     for (var i = 0, l = val.length; i < l; i++) {
       var c = val.charAt(i)
       if (esc) {
-        if ("\\;#".indexOf(c) !== -1)
+        if ('\\;#'.indexOf(c) !== -1) {
           unesc += c
-        else
-          unesc += "\\" + c
+        } else {
+          unesc += '\\' + c
+        }
         esc = false
-      } else if (";#".indexOf(c) !== -1) {
+      } else if (';#'.indexOf(c) !== -1) {
         break
-      } else if (c === "\\") {
+      } else if (c === '\\') {
         esc = true
       } else {
         unesc += c
       }
     }
-    if (esc)
-      unesc += "\\"
-    return unesc
+    if (esc) {
+      unesc += '\\'
+    }
+    return unesc.trim()
   }
   return val
 }