fsevents 1.0.4 → 1.0.5

package/node_modules/node-pre-gyp/node_modules/tar-pack/node_modules/fstream/lib/reader.js

@@ -1,262 +0,0 @@
-
-module.exports = Reader
-
-var fs = require("graceful-fs")
-  , Stream = require("stream").Stream
-  , inherits = require("inherits")
-  , path = require("path")
-  , getType = require("./get-type.js")
-  , hardLinks = Reader.hardLinks = {}
-  , Abstract = require("./abstract.js")
-
-// Must do this *before* loading the child classes
-inherits(Reader, Abstract)
-
-var DirReader = require("./dir-reader.js")
-  , FileReader = require("./file-reader.js")
-  , LinkReader = require("./link-reader.js")
-  , SocketReader = require("./socket-reader.js")
-  , ProxyReader = require("./proxy-reader.js")
-
-function Reader (props, currentStat) {
-  var me = this
-  if (!(me instanceof Reader)) return new Reader(props, currentStat)
-
-  if (typeof props === "string") {
-    props = { path: props }
-  }
-
-  if (!props.path) {
-    me.error("Must provide a path", null, true)
-  }
-
-  // polymorphism.
-  // call fstream.Reader(dir) to get a DirReader object, etc.
-  // Note that, unlike in the Writer case, ProxyReader is going
-  // to be the *normal* state of affairs, since we rarely know
-  // the type of a file prior to reading it.
-
-
-  var type
-    , ClassType
-
-  if (props.type && typeof props.type === "function") {
-    type = props.type
-    ClassType = type
-  } else {
-    type = getType(props)
-    ClassType = Reader
-  }
-
-  if (currentStat && !type) {
-    type = getType(currentStat)
-    props[type] = true
-    props.type = type
-  }
-
-  switch (type) {
-    case "Directory":
-      ClassType = DirReader
-      break
-
-    case "Link":
-      // XXX hard links are just files.
-      // However, it would be good to keep track of files' dev+inode
-      // and nlink values, and create a HardLinkReader that emits
-      // a linkpath value of the original copy, so that the tar
-      // writer can preserve them.
-      // ClassType = HardLinkReader
-      // break
-
-    case "File":
-      ClassType = FileReader
-      break
-
-    case "SymbolicLink":
-      ClassType = LinkReader
-      break
-
-    case "Socket":
-      ClassType = SocketReader
-      break
-
-    case null:
-      ClassType = ProxyReader
-      break
-  }
-
-  if (!(me instanceof ClassType)) {
-    return new ClassType(props)
-  }
-
-  Abstract.call(me)
-
-  me.readable = true
-  me.writable = false
-
-  me.type = type
-  me.props = props
-  me.depth = props.depth = props.depth || 0
-  me.parent = props.parent || null
-  me.root = props.root || (props.parent && props.parent.root) || me
-
-  me._path = me.path = path.resolve(props.path)
-  if (process.platform === "win32") {
-    me.path = me._path = me.path.replace(/\?/g, "_")
-    if (me._path.length >= 260) {
-      // how DOES one create files on the moon?
-      // if the path has spaces in it, then UNC will fail.
-      me._swallowErrors = true
-      //if (me._path.indexOf(" ") === -1) {
-        me._path = "\\\\?\\" + me.path.replace(/\//g, "\\")
-      //}
-    }
-  }
-  me.basename = props.basename = path.basename(me.path)
-  me.dirname = props.dirname = path.dirname(me.path)
-
-  // these have served their purpose, and are now just noisy clutter
-  props.parent = props.root = null
-
-  // console.error("\n\n\n%s setting size to", props.path, props.size)
-  me.size = props.size
-  me.filter = typeof props.filter === "function" ? props.filter : null
-  if (props.sort === "alpha") props.sort = alphasort
-
-  // start the ball rolling.
-  // this will stat the thing, and then call me._read()
-  // to start reading whatever it is.
-  // console.error("calling stat", props.path, currentStat)
-  me._stat(currentStat)
-}
-
-function alphasort (a, b) {
-  return a === b ? 0
-       : a.toLowerCase() > b.toLowerCase() ? 1
-       : a.toLowerCase() < b.toLowerCase() ? -1
-       : a > b ? 1
-       : -1
-}
-
-Reader.prototype._stat = function (currentStat) {
-  var me = this
-    , props = me.props
-    , stat = props.follow ? "stat" : "lstat"
-  // console.error("Reader._stat", me._path, currentStat)
-  if (currentStat) process.nextTick(statCb.bind(null, null, currentStat))
-  else fs[stat](me._path, statCb)
-
-
-  function statCb (er, props_) {
-    // console.error("Reader._stat, statCb", me._path, props_, props_.nlink)
-    if (er) return me.error(er)
-
-    Object.keys(props_).forEach(function (k) {
-      props[k] = props_[k]
-    })
-
-    // if it's not the expected size, then abort here.
-    if (undefined !== me.size && props.size !== me.size) {
-      return me.error("incorrect size")
-    }
-    me.size = props.size
-
-    var type = getType(props)
-    var handleHardlinks = props.hardlinks !== false
-    
-    // special little thing for handling hardlinks.
-    if (handleHardlinks && type !== "Directory" && props.nlink && props.nlink > 1) {
-      var k = props.dev + ":" + props.ino
-      // console.error("Reader has nlink", me._path, k)
-      if (hardLinks[k] === me._path || !hardLinks[k]) hardLinks[k] = me._path
-      else {
-        // switch into hardlink mode.
-        type = me.type = me.props.type = "Link"
-        me.Link = me.props.Link = true
-        me.linkpath = me.props.linkpath = hardLinks[k]
-        // console.error("Hardlink detected, switching mode", me._path, me.linkpath)
-        // Setting __proto__ would arguably be the "correct"
-        // approach here, but that just seems too wrong.
-        me._stat = me._read = LinkReader.prototype._read
-      }
-    }
-
-    if (me.type && me.type !== type) {
-      me.error("Unexpected type: " + type)
-    }
-
-    // if the filter doesn't pass, then just skip over this one.
-    // still have to emit end so that dir-walking can move on.
-    if (me.filter) {
-      var who = me._proxy || me
-      // special handling for ProxyReaders
-      if (!me.filter.call(who, who, props)) {
-        if (!me._disowned) {
-          me.abort()
-          me.emit("end")
-          me.emit("close")
-        }
-        return
-      }
-    }
-
-    // last chance to abort or disown before the flow starts!
-    var events = ["_stat", "stat", "ready"]
-    var e = 0
-    ;(function go () {
-      if (me._aborted) {
-        me.emit("end")
-        me.emit("close")
-        return
-      }
-
-      if (me._paused && me.type !== "Directory") {
-        me.once("resume", go)
-        return
-      }
-
-      var ev = events[e ++]
-      if (!ev) {
-        return me._read()
-      }
-      me.emit(ev, props)
-      go()
-    })()
-  }
-}
-
-Reader.prototype.pipe = function (dest, opts) {
-  var me = this
-  if (typeof dest.add === "function") {
-    // piping to a multi-compatible, and we've got directory entries.
-    me.on("entry", function (entry) {
-      var ret = dest.add(entry)
-      if (false === ret) {
-        me.pause()
-      }
-    })
-  }
-
-  // console.error("R Pipe apply Stream Pipe")
-  return Stream.prototype.pipe.apply(this, arguments)
-}
-
-Reader.prototype.pause = function (who) {
-  this._paused = true
-  who = who || this
-  this.emit("pause", who)
-  if (this._stream) this._stream.pause(who)
-}
-
-Reader.prototype.resume = function (who) {
-  this._paused = false
-  who = who || this
-  this.emit("resume", who)
-  if (this._stream) this._stream.resume(who)
-  this._read()
-}
-
-Reader.prototype._read = function () {
-  this.error("Cannot read unknown type: "+this.type)
-}
-

package/node_modules/node-pre-gyp/node_modules/tar-pack/node_modules/fstream/lib/socket-reader.js

@@ -1,38 +0,0 @@
-// Just get the stats, and then don't do anything.
-// You can't really "read" from a socket.  You "connect" to it.
-// Mostly, this is here so that reading a dir with a socket in it
-// doesn't blow up.
-
-module.exports = SocketReader
-
-var fs = require("graceful-fs")
-  , fstream = require("../fstream.js")
-  , inherits = require("inherits")
-  , mkdir = require("mkdirp")
-  , Reader = require("./reader.js")
-
-inherits(SocketReader, Reader)
-
-function SocketReader (props) {
-  var me = this
-  if (!(me instanceof SocketReader)) throw new Error(
-    "SocketReader must be called as constructor.")
-
-  if (!(props.type === "Socket" && props.Socket)) {
-    throw new Error("Non-socket type "+ props.type)
-  }
-
-  Reader.call(me, props)
-}
-
-SocketReader.prototype._read = function () {
-  var me = this
-  if (me._paused) return
-  // basically just a no-op, since we got all the info we have
-  // from the _stat method
-  if (!me._ended) {
-    me.emit("end")
-    me.emit("close")
-    me._ended = true
-  }
-}

package/node_modules/node-pre-gyp/node_modules/tar-pack/node_modules/fstream/lib/writer.js

@@ -1,389 +0,0 @@
-
-module.exports = Writer
-
-var fs = require("graceful-fs")
-  , inherits = require("inherits")
-  , rimraf = require("rimraf")
-  , mkdir = require("mkdirp")
-  , path = require("path")
-  , umask = process.platform === "win32" ? 0 : process.umask()
-  , getType = require("./get-type.js")
-  , Abstract = require("./abstract.js")
-
-// Must do this *before* loading the child classes
-inherits(Writer, Abstract)
-
-Writer.dirmode = 0777 & (~umask)
-Writer.filemode = 0666 & (~umask)
-
-var DirWriter = require("./dir-writer.js")
-  , LinkWriter = require("./link-writer.js")
-  , FileWriter = require("./file-writer.js")
-  , ProxyWriter = require("./proxy-writer.js")
-
-// props is the desired state.  current is optionally the current stat,
-// provided here so that subclasses can avoid statting the target
-// more than necessary.
-function Writer (props, current) {
-  var me = this
-
-  if (typeof props === "string") {
-    props = { path: props }
-  }
-
-  if (!props.path) me.error("Must provide a path", null, true)
-
-  // polymorphism.
-  // call fstream.Writer(dir) to get a DirWriter object, etc.
-  var type = getType(props)
-    , ClassType = Writer
-
-  switch (type) {
-    case "Directory":
-      ClassType = DirWriter
-      break
-    case "File":
-      ClassType = FileWriter
-      break
-    case "Link":
-    case "SymbolicLink":
-      ClassType = LinkWriter
-      break
-    case null:
-      // Don't know yet what type to create, so we wrap in a proxy.
-      ClassType = ProxyWriter
-      break
-  }
-
-  if (!(me instanceof ClassType)) return new ClassType(props)
-
-  // now get down to business.
-
-  Abstract.call(me)
-
-  // props is what we want to set.
-  // set some convenience properties as well.
-  me.type = props.type
-  me.props = props
-  me.depth = props.depth || 0
-  me.clobber = false === props.clobber ? props.clobber : true
-  me.parent = props.parent || null
-  me.root = props.root || (props.parent && props.parent.root) || me
-
-  me._path = me.path = path.resolve(props.path)
-  if (process.platform === "win32") {
-    me.path = me._path = me.path.replace(/\?/g, "_")
-    if (me._path.length >= 260) {
-      me._swallowErrors = true
-      me._path = "\\\\?\\" + me.path.replace(/\//g, "\\")
-    }
-  }
-  me.basename = path.basename(props.path)
-  me.dirname = path.dirname(props.path)
-  me.linkpath = props.linkpath || null
-
-  props.parent = props.root = null
-
-  // console.error("\n\n\n%s setting size to", props.path, props.size)
-  me.size = props.size
-
-  if (typeof props.mode === "string") {
-    props.mode = parseInt(props.mode, 8)
-  }
-
-  me.readable = false
-  me.writable = true
-
-  // buffer until ready, or while handling another entry
-  me._buffer = []
-  me.ready = false
-
-  me.filter = typeof props.filter === "function" ? props.filter: null
-
-  // start the ball rolling.
-  // this checks what's there already, and then calls
-  // me._create() to call the impl-specific creation stuff.
-  me._stat(current)
-}
-
-// Calling this means that it's something we can't create.
-// Just assert that it's already there, otherwise raise a warning.
-Writer.prototype._create = function () {
-  var me = this
-  fs[me.props.follow ? "stat" : "lstat"](me._path, function (er, current) {
-    if (er) {
-      return me.warn("Cannot create " + me._path + "\n" +
-                     "Unsupported type: "+me.type, "ENOTSUP")
-    }
-    me._finish()
-  })
-}
-
-Writer.prototype._stat = function (current) {
-  var me = this
-    , props = me.props
-    , stat = props.follow ? "stat" : "lstat"
-    , who = me._proxy || me
-
-  if (current) statCb(null, current)
-  else fs[stat](me._path, statCb)
-
-  function statCb (er, current) {
-    if (me.filter && !me.filter.call(who, who, current)) {
-      me._aborted = true
-      me.emit("end")
-      me.emit("close")
-      return
-    }
-
-    // if it's not there, great.  We'll just create it.
-    // if it is there, then we'll need to change whatever differs
-    if (er || !current) {
-      return create(me)
-    }
-
-    me._old = current
-    var currentType = getType(current)
-
-    // if it's a type change, then we need to clobber or error.
-    // if it's not a type change, then let the impl take care of it.
-    if (currentType !== me.type) {
-      return rimraf(me._path, function (er) {
-        if (er) return me.error(er)
-        me._old = null
-        create(me)
-      })
-    }
-
-    // otherwise, just handle in the app-specific way
-    // this creates a fs.WriteStream, or mkdir's, or whatever
-    create(me)
-  }
-}
-
-function create (me) {
-  // console.error("W create", me._path, Writer.dirmode)
-
-  // XXX Need to clobber non-dirs that are in the way,
-  // unless { clobber: false } in the props.
-  mkdir(path.dirname(me._path), Writer.dirmode, function (er, made) {
-    // console.error("W created", path.dirname(me._path), er)
-    if (er) return me.error(er)
-
-    // later on, we have to set the mode and owner for these
-    me._madeDir = made
-    return me._create()
-  })
-}
-
-function endChmod (me, want, current, path, cb) {
-    var wantMode = want.mode
-      , chmod = want.follow || me.type !== "SymbolicLink"
-              ? "chmod" : "lchmod"
-
-  if (!fs[chmod]) return cb()
-  if (typeof wantMode !== "number") return cb()
-
-  var curMode = current.mode & 0777
-  wantMode = wantMode & 0777
-  if (wantMode === curMode) return cb()
-
-  fs[chmod](path, wantMode, cb)
-}
-
-
-function endChown (me, want, current, path, cb) {
-  // Don't even try it unless root.  Too easy to EPERM.
-  if (process.platform === "win32") return cb()
-  if (!process.getuid || !process.getuid() === 0) return cb()
-  if (typeof want.uid !== "number" &&
-      typeof want.gid !== "number" ) return cb()
-
-  if (current.uid === want.uid &&
-      current.gid === want.gid) return cb()
-
-  var chown = (me.props.follow || me.type !== "SymbolicLink")
-            ? "chown" : "lchown"
-  if (!fs[chown]) return cb()
-
-  if (typeof want.uid !== "number") want.uid = current.uid
-  if (typeof want.gid !== "number") want.gid = current.gid
-
-  fs[chown](path, want.uid, want.gid, cb)
-}
-
-function endUtimes (me, want, current, path, cb) {
-  if (!fs.utimes || process.platform === "win32") return cb()
-
-  var utimes = (want.follow || me.type !== "SymbolicLink")
-             ? "utimes" : "lutimes"
-
-  if (utimes === "lutimes" && !fs[utimes]) {
-    utimes = "utimes"
-  }
-
-  if (!fs[utimes]) return cb()
-
-  var curA = current.atime
-    , curM = current.mtime
-    , meA = want.atime
-    , meM = want.mtime
-
-  if (meA === undefined) meA = curA
-  if (meM === undefined) meM = curM
-
-  if (!isDate(meA)) meA = new Date(meA)
-  if (!isDate(meM)) meA = new Date(meM)
-
-  if (meA.getTime() === curA.getTime() &&
-      meM.getTime() === curM.getTime()) return cb()
-
-  fs[utimes](path, meA, meM, cb)
-}
-
-
-// XXX This function is beastly.  Break it up!
-Writer.prototype._finish = function () {
-  var me = this
-
-  // console.error(" W Finish", me._path, me.size)
-
-  // set up all the things.
-  // At this point, we're already done writing whatever we've gotta write,
-  // adding files to the dir, etc.
-  var todo = 0
-  var errState = null
-  var done = false
-
-  if (me._old) {
-    // the times will almost *certainly* have changed.
-    // adds the utimes syscall, but remove another stat.
-    me._old.atime = new Date(0)
-    me._old.mtime = new Date(0)
-    // console.error(" W Finish Stale Stat", me._path, me.size)
-    setProps(me._old)
-  } else {
-    var stat = me.props.follow ? "stat" : "lstat"
-    // console.error(" W Finish Stating", me._path, me.size)
-    fs[stat](me._path, function (er, current) {
-      // console.error(" W Finish Stated", me._path, me.size, current)
-      if (er) {
-        // if we're in the process of writing out a
-        // directory, it's very possible that the thing we're linking to
-        // doesn't exist yet (especially if it was intended as a symlink),
-        // so swallow ENOENT errors here and just soldier on.
-        if (er.code === "ENOENT" &&
-            (me.type === "Link" || me.type === "SymbolicLink") &&
-            process.platform === "win32") {
-          me.ready = true
-          me.emit("ready")
-          me.emit("end")
-          me.emit("close")
-          me.end = me._finish = function () {}
-          return
-        } else return me.error(er)
-      }
-      setProps(me._old = current)
-    })
-  }
-
-  return
-
-  function setProps (current) {
-    todo += 3
-    endChmod(me, me.props, current, me._path, next("chmod"))
-    endChown(me, me.props, current, me._path, next("chown"))
-    endUtimes(me, me.props, current, me._path, next("utimes"))
-  }
-
-  function next (what) {
-    return function (er) {
-      // console.error("   W Finish", what, todo)
-      if (errState) return
-      if (er) {
-        er.fstream_finish_call = what
-        return me.error(errState = er)
-      }
-      if (--todo > 0) return
-      if (done) return
-      done = true
-
-      // we may still need to set the mode/etc. on some parent dirs
-      // that were created previously.  delay end/close until then.
-      if (!me._madeDir) return end()
-      else endMadeDir(me, me._path, end)
-
-      function end (er) {
-        if (er) {
-          er.fstream_finish_call = "setupMadeDir"
-          return me.error(er)
-        }
-        // all the props have been set, so we're completely done.
-        me.emit("end")
-        me.emit("close")
-      }
-    }
-  }
-}
-
-function endMadeDir (me, p, cb) {
-  var made = me._madeDir
-  // everything *between* made and path.dirname(me._path)
-  // needs to be set up.  Note that this may just be one dir.
-  var d = path.dirname(p)
-
-  endMadeDir_(me, d, function (er) {
-    if (er) return cb(er)
-    if (d === made) {
-      return cb()
-    }
-    endMadeDir(me, d, cb)
-  })
-}
-
-function endMadeDir_ (me, p, cb) {
-  var dirProps = {}
-  Object.keys(me.props).forEach(function (k) {
-    dirProps[k] = me.props[k]
-
-    // only make non-readable dirs if explicitly requested.
-    if (k === "mode" && me.type !== "Directory") {
-      dirProps[k] = dirProps[k] | 0111
-    }
-  })
-
-  var todo = 3
-  , errState = null
-  fs.stat(p, function (er, current) {
-    if (er) return cb(errState = er)
-    endChmod(me, dirProps, current, p, next)
-    endChown(me, dirProps, current, p, next)
-    endUtimes(me, dirProps, current, p, next)
-  })
-
-  function next (er) {
-    if (errState) return
-    if (er) return cb(errState = er)
-    if (-- todo === 0) return cb()
-  }
-}
-
-Writer.prototype.pipe = function () {
-  this.error("Can't pipe from writable stream")
-}
-
-Writer.prototype.add = function () {
-  this.error("Cannot add to non-Directory type")
-}
-
-Writer.prototype.write = function () {
-  return true
-}
-
-function objectToString (d) {
-  return Object.prototype.toString.call(d)
-}
-
-function isDate(d) {
-  return typeof d === 'object' && objectToString(d) === '[object Date]';
-}

package/node_modules/node-pre-gyp/node_modules/tar-pack/node_modules/fstream/node_modules/graceful-fs/.npmignore

@@ -1 +0,0 @@
-node_modules/

package/node_modules/node-pre-gyp/node_modules/tar-pack/node_modules/fstream/node_modules/graceful-fs/fs.js

@@ -1,11 +0,0 @@
-// eeeeeevvvvviiiiiiillllll
-// more evil than monkey-patching the native builtin?
-// Not sure.
-
-var mod = require("module")
-var pre = '(function (exports, require, module, __filename, __dirname) { '
-var post = '});'
-var src = pre + process.binding('natives').fs + post
-var vm = require('vm')
-var fn = vm.runInThisContext(src)
-fn(exports, require, module, __filename, __dirname)