fsevents 1.0.4 → 1.0.5

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

@@ -1,147 +0,0 @@
-// Basically just a wrapper around an fs.ReadStream
-
-module.exports = FileReader
-
-var fs = require("graceful-fs")
-  , fstream = require("../fstream.js")
-  , Reader = fstream.Reader
-  , inherits = require("inherits")
-  , mkdir = require("mkdirp")
-  , Reader = require("./reader.js")
-  , EOF = {EOF: true}
-  , CLOSE = {CLOSE: true}
-
-inherits(FileReader, Reader)
-
-function FileReader (props) {
-  // console.error("    FR create", props.path, props.size, new Error().stack)
-  var me = this
-  if (!(me instanceof FileReader)) throw new Error(
-    "FileReader must be called as constructor.")
-
-  // should already be established as a File type
-  // XXX Todo: preserve hardlinks by tracking dev+inode+nlink,
-  // with a HardLinkReader class.
-  if (!((props.type === "Link" && props.Link) ||
-        (props.type === "File" && props.File))) {
-    throw new Error("Non-file type "+ props.type)
-  }
-
-  me._buffer = []
-  me._bytesEmitted = 0
-  Reader.call(me, props)
-}
-
-FileReader.prototype._getStream = function () {
-  var me = this
-    , stream = me._stream = fs.createReadStream(me._path, me.props)
-
-  if (me.props.blksize) {
-    stream.bufferSize = me.props.blksize
-  }
-
-  stream.on("open", me.emit.bind(me, "open"))
-
-  stream.on("data", function (c) {
-    // console.error("\t\t%d %s", c.length, me.basename)
-    me._bytesEmitted += c.length
-    // no point saving empty chunks
-    if (!c.length) return
-    else if (me._paused || me._buffer.length) {
-      me._buffer.push(c)
-      me._read()
-    } else me.emit("data", c)
-  })
-
-  stream.on("end", function () {
-    if (me._paused || me._buffer.length) {
-      // console.error("FR Buffering End", me._path)
-      me._buffer.push(EOF)
-      me._read()
-    } else {
-      me.emit("end")
-    }
-
-    if (me._bytesEmitted !== me.props.size) {
-      me.error("Didn't get expected byte count\n"+
-               "expect: "+me.props.size + "\n" +
-               "actual: "+me._bytesEmitted)
-    }
-  })
-
-  stream.on("close", function () {
-    if (me._paused || me._buffer.length) {
-      // console.error("FR Buffering Close", me._path)
-      me._buffer.push(CLOSE)
-      me._read()
-    } else {
-      // console.error("FR close 1", me._path)
-      me.emit("close")
-    }
-  })
-
-  me._read()
-}
-
-FileReader.prototype._read = function () {
-  var me = this
-  // console.error("FR _read", me._path)
-  if (me._paused) {
-    // console.error("FR _read paused", me._path)
-    return
-  }
-
-  if (!me._stream) {
-    // console.error("FR _getStream calling", me._path)
-    return me._getStream()
-  }
-
-  // clear out the buffer, if there is one.
-  if (me._buffer.length) {
-    // console.error("FR _read has buffer", me._buffer.length, me._path)
-    var buf = me._buffer
-    for (var i = 0, l = buf.length; i < l; i ++) {
-      var c = buf[i]
-      if (c === EOF) {
-        // console.error("FR Read emitting buffered end", me._path)
-        me.emit("end")
-      } else if (c === CLOSE) {
-        // console.error("FR Read emitting buffered close", me._path)
-        me.emit("close")
-      } else {
-        // console.error("FR Read emitting buffered data", me._path)
-        me.emit("data", c)
-      }
-
-      if (me._paused) {
-        // console.error("FR Read Re-pausing at "+i, me._path)
-        me._buffer = buf.slice(i)
-        return
-      }
-    }
-    me._buffer.length = 0
-  }
-  // console.error("FR _read done")
-  // that's about all there is to it.
-}
-
-FileReader.prototype.pause = function (who) {
-  var me = this
-  // console.error("FR Pause", me._path)
-  if (me._paused) return
-  who = who || me
-  me._paused = true
-  if (me._stream) me._stream.pause()
-  me.emit("pause", who)
-}
-
-FileReader.prototype.resume = function (who) {
-  var me = this
-  // console.error("FR Resume", me._path)
-  if (!me._paused) return
-  who = who || me
-  me.emit("resume", who)
-  me._paused = false
-  if (me._stream) me._stream.resume()
-  me._read()
-}

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

@@ -1,104 +0,0 @@
-module.exports = FileWriter
-
-var fs = require("graceful-fs")
-  , mkdir = require("mkdirp")
-  , Writer = require("./writer.js")
-  , inherits = require("inherits")
-  , EOF = {}
-
-inherits(FileWriter, Writer)
-
-function FileWriter (props) {
-  var me = this
-  if (!(me instanceof FileWriter)) throw new Error(
-    "FileWriter must be called as constructor.")
-
-  // should already be established as a File type
-  if (props.type !== "File" || !props.File) {
-    throw new Error("Non-file type "+ props.type)
-  }
-
-  me._buffer = []
-  me._bytesWritten = 0
-
-  Writer.call(this, props)
-}
-
-FileWriter.prototype._create = function () {
-  var me = this
-  if (me._stream) return
-
-  var so = {}
-  if (me.props.flags) so.flags = me.props.flags
-  so.mode = Writer.filemode
-  if (me._old && me._old.blksize) so.bufferSize = me._old.blksize
-
-  me._stream = fs.createWriteStream(me._path, so)
-
-  me._stream.on("open", function (fd) {
-    // console.error("FW open", me._buffer, me._path)
-    me.ready = true
-    me._buffer.forEach(function (c) {
-      if (c === EOF) me._stream.end()
-      else me._stream.write(c)
-    })
-    me.emit("ready")
-    // give this a kick just in case it needs it.
-    me.emit("drain")
-  })
-
-  me._stream.on("drain", function () { me.emit("drain") })
-
-  me._stream.on("close", function () {
-    // console.error("\n\nFW Stream Close", me._path, me.size)
-    me._finish()
-  })
-}
-
-FileWriter.prototype.write = function (c) {
-  var me = this
-
-  me._bytesWritten += c.length
-
-  if (!me.ready) {
-    if (!Buffer.isBuffer(c) && typeof c !== 'string')
-      throw new Error('invalid write data')
-    me._buffer.push(c)
-    return false
-  }
-
-  var ret = me._stream.write(c)
-  // console.error("\t-- fw wrote, _stream says", ret, me._stream._queue.length)
-
-  // allow 2 buffered writes, because otherwise there's just too
-  // much stop and go bs.
-  if (ret === false && me._stream._queue) {
-    return me._stream._queue.length <= 2;
-  } else {
-    return ret;
-  }
-}
-
-FileWriter.prototype.end = function (c) {
-  var me = this
-
-  if (c) me.write(c)
-
-  if (!me.ready) {
-    me._buffer.push(EOF)
-    return false
-  }
-
-  return me._stream.end()
-}
-
-FileWriter.prototype._finish = function () {
-  var me = this
-  if (typeof me.size === "number" && me._bytesWritten != me.size) {
-    me.error(
-      "Did not get expected byte count.\n" +
-      "expect: " + me.size + "\n" +
-      "actual: " + me._bytesWritten)
-  }
-  Writer.prototype._finish.call(me)
-}

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

@@ -1,32 +0,0 @@
-module.exports = getType
-
-function getType (st) {
-  var types =
-      [ "Directory"
-      , "File"
-      , "SymbolicLink"
-      , "Link" // special for hardlinks from tarballs
-      , "BlockDevice"
-      , "CharacterDevice"
-      , "FIFO"
-      , "Socket" ]
-    , type
-
-  if (st.type && -1 !== types.indexOf(st.type)) {
-    st[st.type] = true
-    return st.type
-  }
-
-  for (var i = 0, l = types.length; i < l; i ++) {
-    type = types[i]
-    var is = st[type] || st["is" + type]
-    if (typeof is === "function") is = is.call(st)
-    if (is) {
-      st[type] = true
-      st.type = type
-      return type
-    }
-  }
-
-  return null
-}

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

@@ -1,54 +0,0 @@
-// Basically just a wrapper around an fs.readlink
-//
-// XXX: Enhance this to support the Link type, by keeping
-// a lookup table of {<dev+inode>:<path>}, so that hardlinks
-// can be preserved in tarballs.
-
-module.exports = LinkReader
-
-var fs = require("graceful-fs")
-  , fstream = require("../fstream.js")
-  , inherits = require("inherits")
-  , mkdir = require("mkdirp")
-  , Reader = require("./reader.js")
-
-inherits(LinkReader, Reader)
-
-function LinkReader (props) {
-  var me = this
-  if (!(me instanceof LinkReader)) throw new Error(
-    "LinkReader must be called as constructor.")
-
-  if (!((props.type === "Link" && props.Link) ||
-        (props.type === "SymbolicLink" && props.SymbolicLink))) {
-    throw new Error("Non-link type "+ props.type)
-  }
-
-  Reader.call(me, props)
-}
-
-// When piping a LinkReader into a LinkWriter, we have to
-// already have the linkpath property set, so that has to
-// happen *before* the "ready" event, which means we need to
-// override the _stat method.
-LinkReader.prototype._stat = function (currentStat) {
-  var me = this
-  fs.readlink(me._path, function (er, linkpath) {
-    if (er) return me.error(er)
-    me.linkpath = me.props.linkpath = linkpath
-    me.emit("linkpath", linkpath)
-    Reader.prototype._stat.call(me, currentStat)
-  })
-}
-
-LinkReader.prototype._read = function () {
-  var me = this
-  if (me._paused) return
-  // basically just a no-op, since we got all the info we need
-  // 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/link-writer.js

@@ -1,95 +0,0 @@
-
-module.exports = LinkWriter
-
-var fs = require("graceful-fs")
-  , Writer = require("./writer.js")
-  , inherits = require("inherits")
-  , path = require("path")
-  , rimraf = require("rimraf")
-
-inherits(LinkWriter, Writer)
-
-function LinkWriter (props) {
-  var me = this
-  if (!(me instanceof LinkWriter)) throw new Error(
-    "LinkWriter must be called as constructor.")
-
-  // should already be established as a Link type
-  if (!((props.type === "Link" && props.Link) ||
-        (props.type === "SymbolicLink" && props.SymbolicLink))) {
-    throw new Error("Non-link type "+ props.type)
-  }
-
-  if (props.linkpath === "") props.linkpath = "."
-  if (!props.linkpath) {
-    me.error("Need linkpath property to create " + props.type)
-  }
-
-  Writer.call(this, props)
-}
-
-LinkWriter.prototype._create = function () {
-  // console.error(" LW _create")
-  var me = this
-    , hard = me.type === "Link" || process.platform === "win32"
-    , link = hard ? "link" : "symlink"
-    , lp = hard ? path.resolve(me.dirname, me.linkpath) : me.linkpath
-
-  // can only change the link path by clobbering
-  // For hard links, let's just assume that's always the case, since
-  // there's no good way to read them if we don't already know.
-  if (hard) return clobber(me, lp, link)
-
-  fs.readlink(me._path, function (er, p) {
-    // only skip creation if it's exactly the same link
-    if (p && p === lp) return finish(me)
-    clobber(me, lp, link)
-  })
-}
-
-function clobber (me, lp, link) {
-  rimraf(me._path, function (er) {
-    if (er) return me.error(er)
-    create(me, lp, link)
-  })
-}
-
-function create (me, lp, link) {
-  fs[link](lp, me._path, function (er) {
-    // if this is a hard link, and 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 in.
-    // Additionally, an EPERM or EACCES can happen on win32 if it's trying
-    // to make a link to a directory.  Again, just skip it.
-    // A better solution would be to have fs.symlink be supported on
-    // windows in some nice fashion.
-    if (er) {
-      if ((er.code === "ENOENT" ||
-           er.code === "EACCES" ||
-           er.code === "EPERM" ) && process.platform === "win32") {
-        me.ready = true
-        me.emit("ready")
-        me.emit("end")
-        me.emit("close")
-        me.end = me._finish = function () {}
-      } else return me.error(er)
-    }
-    finish(me)
-  })
-}
-
-function finish (me) {
-  me.ready = true
-  me.emit("ready")
-  if (me._ended && !me._finished) me._finish()
-}
-
-LinkWriter.prototype.end = function () {
-  // console.error("LW finish in end")
-  this._ended = true
-  if (this.ready) {
-    this._finished = true
-    this._finish()
-  }
-}

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

@@ -1,93 +0,0 @@
-// A reader for when we don't yet know what kind of thing
-// the thing is.
-
-module.exports = ProxyReader
-
-var Reader = require("./reader.js")
-  , getType = require("./get-type.js")
-  , inherits = require("inherits")
-  , fs = require("graceful-fs")
-
-inherits(ProxyReader, Reader)
-
-function ProxyReader (props) {
-  var me = this
-  if (!(me instanceof ProxyReader)) throw new Error(
-    "ProxyReader must be called as constructor.")
-
-  me.props = props
-  me._buffer = []
-  me.ready = false
-
-  Reader.call(me, props)
-}
-
-ProxyReader.prototype._stat = function () {
-  var me = this
-    , props = me.props
-    // stat the thing to see what the proxy should be.
-    , stat = props.follow ? "stat" : "lstat"
-
-  fs[stat](props.path, function (er, current) {
-    var type
-    if (er || !current) {
-      type = "File"
-    } else {
-      type = getType(current)
-    }
-
-    props[type] = true
-    props.type = me.type = type
-
-    me._old = current
-    me._addProxy(Reader(props, current))
-  })
-}
-
-ProxyReader.prototype._addProxy = function (proxy) {
-  var me = this
-  if (me._proxyTarget) {
-    return me.error("proxy already set")
-  }
-
-  me._proxyTarget = proxy
-  proxy._proxy = me
-
-  ; [ "error"
-    , "data"
-    , "end"
-    , "close"
-    , "linkpath"
-    , "entry"
-    , "entryEnd"
-    , "child"
-    , "childEnd"
-    , "warn"
-    , "stat"
-    ].forEach(function (ev) {
-      // console.error("~~ proxy event", ev, me.path)
-      proxy.on(ev, me.emit.bind(me, ev))
-    })
-
-  me.emit("proxy", proxy)
-
-  proxy.on("ready", function () {
-    // console.error("~~ proxy is ready!", me.path)
-    me.ready = true
-    me.emit("ready")
-  })
-
-  var calls = me._buffer
-  me._buffer.length = 0
-  calls.forEach(function (c) {
-    proxy[c[0]].apply(proxy, c[1])
-  })
-}
-
-ProxyReader.prototype.pause = function () {
-  return this._proxyTarget ? this._proxyTarget.pause() : false
-}
-
-ProxyReader.prototype.resume = function () {
-  return this._proxyTarget ? this._proxyTarget.resume() : false
-}

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

@@ -1,109 +0,0 @@
-// A writer for when we don't know what kind of thing
-// the thing is.  That is, it's not explicitly set,
-// so we're going to make it whatever the thing already
-// is, or "File"
-//
-// Until then, collect all events.
-
-module.exports = ProxyWriter
-
-var Writer = require("./writer.js")
-  , getType = require("./get-type.js")
-  , inherits = require("inherits")
-  , collect = require("./collect.js")
-  , fs = require("fs")
-
-inherits(ProxyWriter, Writer)
-
-function ProxyWriter (props) {
-  var me = this
-  if (!(me instanceof ProxyWriter)) throw new Error(
-    "ProxyWriter must be called as constructor.")
-
-  me.props = props
-  me._needDrain = false
-
-  Writer.call(me, props)
-}
-
-ProxyWriter.prototype._stat = function () {
-  var me = this
-    , props = me.props
-    // stat the thing to see what the proxy should be.
-    , stat = props.follow ? "stat" : "lstat"
-
-  fs[stat](props.path, function (er, current) {
-    var type
-    if (er || !current) {
-      type = "File"
-    } else {
-      type = getType(current)
-    }
-
-    props[type] = true
-    props.type = me.type = type
-
-    me._old = current
-    me._addProxy(Writer(props, current))
-  })
-}
-
-ProxyWriter.prototype._addProxy = function (proxy) {
-  // console.error("~~ set proxy", this.path)
-  var me = this
-  if (me._proxy) {
-    return me.error("proxy already set")
-  }
-
-  me._proxy = proxy
-  ; [ "ready"
-    , "error"
-    , "close"
-    , "pipe"
-    , "drain"
-    , "warn"
-    ].forEach(function (ev) {
-      proxy.on(ev, me.emit.bind(me, ev))
-    })
-
-  me.emit("proxy", proxy)
-
-  var calls = me._buffer
-  calls.forEach(function (c) {
-    // console.error("~~ ~~ proxy buffered call", c[0], c[1])
-    proxy[c[0]].apply(proxy, c[1])
-  })
-  me._buffer.length = 0
-  if (me._needsDrain) me.emit("drain")
-}
-
-ProxyWriter.prototype.add = function (entry) {
-  // console.error("~~ proxy add")
-  collect(entry)
-
-  if (!this._proxy) {
-    this._buffer.push(["add", [entry]])
-    this._needDrain = true
-    return false
-  }
-  return this._proxy.add(entry)
-}
-
-ProxyWriter.prototype.write = function (c) {
-  // console.error("~~ proxy write")
-  if (!this._proxy) {
-    this._buffer.push(["write", [c]])
-    this._needDrain = true
-    return false
-  }
-  return this._proxy.write(c)
-}
-
-ProxyWriter.prototype.end = function (c) {
-  // console.error("~~ proxy end")
-  if (!this._proxy) {
-    this._buffer.push(["end", [c]])
-    return false
-  }
-  return this._proxy.end(c)
-}