fsevents 1.1.1 → 1.2.2

package/node_modules/fstream/lib/link-reader.js

@@ -1,53 +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')
-var inherits = require('inherits')
-var Reader = require('./reader.js')
-
-inherits(LinkReader, Reader)
-
-function LinkReader (props) {
-  var self = this
-  if (!(self 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(self, 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 self = this
-  fs.readlink(self._path, function (er, linkpath) {
-    if (er) return self.error(er)
-    self.linkpath = self.props.linkpath = linkpath
-    self.emit('linkpath', linkpath)
-    Reader.prototype._stat.call(self, currentStat)
-  })
-}
-
-LinkReader.prototype._read = function () {
-  var self = this
-  if (self._paused) return
-  // basically just a no-op, since we got all the info we need
-  // from the _stat method
-  if (!self._ended) {
-    self.emit('end')
-    self.emit('close')
-    self._ended = true
-  }
-}

package/node_modules/fstream/lib/link-writer.js

@@ -1,95 +0,0 @@
-module.exports = LinkWriter
-
-var fs = require('graceful-fs')
-var Writer = require('./writer.js')
-var inherits = require('inherits')
-var path = require('path')
-var rimraf = require('rimraf')
-
-inherits(LinkWriter, Writer)
-
-function LinkWriter (props) {
-  var self = this
-  if (!(self 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) {
-    self.error('Need linkpath property to create ' + props.type)
-  }
-
-  Writer.call(this, props)
-}
-
-LinkWriter.prototype._create = function () {
-  // console.error(" LW _create")
-  var self = this
-  var hard = self.type === 'Link' || process.platform === 'win32'
-  var link = hard ? 'link' : 'symlink'
-  var lp = hard ? path.resolve(self.dirname, self.linkpath) : self.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(self, lp, link)
-
-  fs.readlink(self._path, function (er, p) {
-    // only skip creation if it's exactly the same link
-    if (p && p === lp) return finish(self)
-    clobber(self, lp, link)
-  })
-}
-
-function clobber (self, lp, link) {
-  rimraf(self._path, function (er) {
-    if (er) return self.error(er)
-    create(self, lp, link)
-  })
-}
-
-function create (self, lp, link) {
-  fs[link](lp, self._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') {
-        self.ready = true
-        self.emit('ready')
-        self.emit('end')
-        self.emit('close')
-        self.end = self._finish = function () {}
-      } else return self.error(er)
-    }
-    finish(self)
-  })
-}
-
-function finish (self) {
-  self.ready = true
-  self.emit('ready')
-  if (self._ended && !self._finished) self._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/fstream/lib/proxy-reader.js

@@ -1,95 +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')
-var getType = require('./get-type.js')
-var inherits = require('inherits')
-var fs = require('graceful-fs')
-
-inherits(ProxyReader, Reader)
-
-function ProxyReader (props) {
-  var self = this
-  if (!(self instanceof ProxyReader)) {
-    throw new Error('ProxyReader must be called as constructor.')
-  }
-
-  self.props = props
-  self._buffer = []
-  self.ready = false
-
-  Reader.call(self, props)
-}
-
-ProxyReader.prototype._stat = function () {
-  var self = this
-  var props = self.props
-  // stat the thing to see what the proxy should be.
-  var 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 = self.type = type
-
-    self._old = current
-    self._addProxy(Reader(props, current))
-  })
-}
-
-ProxyReader.prototype._addProxy = function (proxy) {
-  var self = this
-  if (self._proxyTarget) {
-    return self.error('proxy already set')
-  }
-
-  self._proxyTarget = proxy
-  proxy._proxy = self
-
-  ;[
-    'error',
-    'data',
-    'end',
-    'close',
-    'linkpath',
-    'entry',
-    'entryEnd',
-    'child',
-    'childEnd',
-    'warn',
-    'stat'
-  ].forEach(function (ev) {
-    // console.error('~~ proxy event', ev, self.path)
-    proxy.on(ev, self.emit.bind(self, ev))
-  })
-
-  self.emit('proxy', proxy)
-
-  proxy.on('ready', function () {
-    // console.error("~~ proxy is ready!", self.path)
-    self.ready = true
-    self.emit('ready')
-  })
-
-  var calls = self._buffer
-  self._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/fstream/lib/proxy-writer.js

@@ -1,111 +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')
-var getType = require('./get-type.js')
-var inherits = require('inherits')
-var collect = require('./collect.js')
-var fs = require('fs')
-
-inherits(ProxyWriter, Writer)
-
-function ProxyWriter (props) {
-  var self = this
-  if (!(self instanceof ProxyWriter)) {
-    throw new Error('ProxyWriter must be called as constructor.')
-  }
-
-  self.props = props
-  self._needDrain = false
-
-  Writer.call(self, props)
-}
-
-ProxyWriter.prototype._stat = function () {
-  var self = this
-  var props = self.props
-  // stat the thing to see what the proxy should be.
-  var 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 = self.type = type
-
-    self._old = current
-    self._addProxy(Writer(props, current))
-  })
-}
-
-ProxyWriter.prototype._addProxy = function (proxy) {
-  // console.error("~~ set proxy", this.path)
-  var self = this
-  if (self._proxy) {
-    return self.error('proxy already set')
-  }
-
-  self._proxy = proxy
-  ;[
-    'ready',
-    'error',
-    'close',
-    'pipe',
-    'drain',
-    'warn'
-  ].forEach(function (ev) {
-    proxy.on(ev, self.emit.bind(self, ev))
-  })
-
-  self.emit('proxy', proxy)
-
-  var calls = self._buffer
-  calls.forEach(function (c) {
-    // console.error("~~ ~~ proxy buffered call", c[0], c[1])
-    proxy[c[0]].apply(proxy, c[1])
-  })
-  self._buffer.length = 0
-  if (self._needsDrain) self.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)
-}

package/node_modules/fstream/lib/reader.js

@@ -1,255 +0,0 @@
-module.exports = Reader
-
-var fs = require('graceful-fs')
-var Stream = require('stream').Stream
-var inherits = require('inherits')
-var path = require('path')
-var getType = require('./get-type.js')
-var hardLinks = Reader.hardLinks = {}
-var Abstract = require('./abstract.js')
-
-// Must do this *before* loading the child classes
-inherits(Reader, Abstract)
-
-var LinkReader = require('./link-reader.js')
-
-function Reader (props, currentStat) {
-  var self = this
-  if (!(self instanceof Reader)) return new Reader(props, currentStat)
-
-  if (typeof props === 'string') {
-    props = { path: props }
-  }
-
-  if (!props.path) {
-    self.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
-  var 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 = require('./dir-reader.js')
-      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 = require('./file-reader.js')
-      break
-
-    case 'SymbolicLink':
-      ClassType = LinkReader
-      break
-
-    case 'Socket':
-      ClassType = require('./socket-reader.js')
-      break
-
-    case null:
-      ClassType = require('./proxy-reader.js')
-      break
-  }
-
-  if (!(self instanceof ClassType)) {
-    return new ClassType(props)
-  }
-
-  Abstract.call(self)
-
-  self.readable = true
-  self.writable = false
-
-  self.type = type
-  self.props = props
-  self.depth = props.depth = props.depth || 0
-  self.parent = props.parent || null
-  self.root = props.root || (props.parent && props.parent.root) || self
-
-  self._path = self.path = path.resolve(props.path)
-  if (process.platform === 'win32') {
-    self.path = self._path = self.path.replace(/\?/g, '_')
-    if (self._path.length >= 260) {
-      // how DOES one create files on the moon?
-      // if the path has spaces in it, then UNC will fail.
-      self._swallowErrors = true
-      // if (self._path.indexOf(" ") === -1) {
-      self._path = '\\\\?\\' + self.path.replace(/\//g, '\\')
-    // }
-    }
-  }
-  self.basename = props.basename = path.basename(self.path)
-  self.dirname = props.dirname = path.dirname(self.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)
-  self.size = props.size
-  self.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 self._read()
-  // to start reading whatever it is.
-  // console.error("calling stat", props.path, currentStat)
-  self._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 self = this
-  var props = self.props
-  var stat = props.follow ? 'stat' : 'lstat'
-  // console.error("Reader._stat", self._path, currentStat)
-  if (currentStat) process.nextTick(statCb.bind(null, null, currentStat))
-  else fs[stat](self._path, statCb)
-
-  function statCb (er, props_) {
-    // console.error("Reader._stat, statCb", self._path, props_, props_.nlink)
-    if (er) return self.error(er)
-
-    Object.keys(props_).forEach(function (k) {
-      props[k] = props_[k]
-    })
-
-    // if it's not the expected size, then abort here.
-    if (undefined !== self.size && props.size !== self.size) {
-      return self.error('incorrect size')
-    }
-    self.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", self._path, k)
-      if (hardLinks[k] === self._path || !hardLinks[k]) {
-        hardLinks[k] = self._path
-      } else {
-        // switch into hardlink mode.
-        type = self.type = self.props.type = 'Link'
-        self.Link = self.props.Link = true
-        self.linkpath = self.props.linkpath = hardLinks[k]
-        // console.error("Hardlink detected, switching mode", self._path, self.linkpath)
-        // Setting __proto__ would arguably be the "correct"
-        // approach here, but that just seems too wrong.
-        self._stat = self._read = LinkReader.prototype._read
-      }
-    }
-
-    if (self.type && self.type !== type) {
-      self.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 (self.filter) {
-      var who = self._proxy || self
-      // special handling for ProxyReaders
-      if (!self.filter.call(who, who, props)) {
-        if (!self._disowned) {
-          self.abort()
-          self.emit('end')
-          self.emit('close')
-        }
-        return
-      }
-    }
-
-    // last chance to abort or disown before the flow starts!
-    var events = ['_stat', 'stat', 'ready']
-    var e = 0
-    ;(function go () {
-      if (self._aborted) {
-        self.emit('end')
-        self.emit('close')
-        return
-      }
-
-      if (self._paused && self.type !== 'Directory') {
-        self.once('resume', go)
-        return
-      }
-
-      var ev = events[e++]
-      if (!ev) {
-        return self._read()
-      }
-      self.emit(ev, props)
-      go()
-    })()
-  }
-}
-
-Reader.prototype.pipe = function (dest) {
-  var self = this
-  if (typeof dest.add === 'function') {
-    // piping to a multi-compatible, and we've got directory entries.
-    self.on('entry', function (entry) {
-      var ret = dest.add(entry)
-      if (ret === false) {
-        self.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/fstream/lib/socket-reader.js

@@ -1,36 +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 inherits = require('inherits')
-var Reader = require('./reader.js')
-
-inherits(SocketReader, Reader)
-
-function SocketReader (props) {
-  var self = this
-  if (!(self 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(self, props)
-}
-
-SocketReader.prototype._read = function () {
-  var self = this
-  if (self._paused) return
-  // basically just a no-op, since we got all the info we have
-  // from the _stat method
-  if (!self._ended) {
-    self.emit('end')
-    self.emit('close')
-    self._ended = true
-  }
-}