fsevents 1.1.1 → 1.2.2

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

@@ -1,252 +0,0 @@
-// A thing that emits "entry" events with Reader objects
-// Pausing it causes it to stop emitting entry events, and also
-// pauses the current entry if there is one.
-
-module.exports = DirReader
-
-var fs = require('graceful-fs')
-var inherits = require('inherits')
-var path = require('path')
-var Reader = require('./reader.js')
-var assert = require('assert').ok
-
-inherits(DirReader, Reader)
-
-function DirReader (props) {
-  var self = this
-  if (!(self instanceof DirReader)) {
-    throw new Error('DirReader must be called as constructor.')
-  }
-
-  // should already be established as a Directory type
-  if (props.type !== 'Directory' || !props.Directory) {
-    throw new Error('Non-directory type ' + props.type)
-  }
-
-  self.entries = null
-  self._index = -1
-  self._paused = false
-  self._length = -1
-
-  if (props.sort) {
-    this.sort = props.sort
-  }
-
-  Reader.call(this, props)
-}
-
-DirReader.prototype._getEntries = function () {
-  var self = this
-
-  // race condition.  might pause() before calling _getEntries,
-  // and then resume, and try to get them a second time.
-  if (self._gotEntries) return
-  self._gotEntries = true
-
-  fs.readdir(self._path, function (er, entries) {
-    if (er) return self.error(er)
-
-    self.entries = entries
-
-    self.emit('entries', entries)
-    if (self._paused) self.once('resume', processEntries)
-    else processEntries()
-
-    function processEntries () {
-      self._length = self.entries.length
-      if (typeof self.sort === 'function') {
-        self.entries = self.entries.sort(self.sort.bind(self))
-      }
-      self._read()
-    }
-  })
-}
-
-// start walking the dir, and emit an "entry" event for each one.
-DirReader.prototype._read = function () {
-  var self = this
-
-  if (!self.entries) return self._getEntries()
-
-  if (self._paused || self._currentEntry || self._aborted) {
-    // console.error('DR paused=%j, current=%j, aborted=%j', self._paused, !!self._currentEntry, self._aborted)
-    return
-  }
-
-  self._index++
-  if (self._index >= self.entries.length) {
-    if (!self._ended) {
-      self._ended = true
-      self.emit('end')
-      self.emit('close')
-    }
-    return
-  }
-
-  // ok, handle this one, then.
-
-  // save creating a proxy, by stat'ing the thing now.
-  var p = path.resolve(self._path, self.entries[self._index])
-  assert(p !== self._path)
-  assert(self.entries[self._index])
-
-  // set this to prevent trying to _read() again in the stat time.
-  self._currentEntry = p
-  fs[ self.props.follow ? 'stat' : 'lstat' ](p, function (er, stat) {
-    if (er) return self.error(er)
-
-    var who = self._proxy || self
-
-    stat.path = p
-    stat.basename = path.basename(p)
-    stat.dirname = path.dirname(p)
-    var childProps = self.getChildProps.call(who, stat)
-    childProps.path = p
-    childProps.basename = path.basename(p)
-    childProps.dirname = path.dirname(p)
-
-    var entry = Reader(childProps, stat)
-
-    // console.error("DR Entry", p, stat.size)
-
-    self._currentEntry = entry
-
-    // "entry" events are for direct entries in a specific dir.
-    // "child" events are for any and all children at all levels.
-    // This nomenclature is not completely final.
-
-    entry.on('pause', function (who) {
-      if (!self._paused && !entry._disowned) {
-        self.pause(who)
-      }
-    })
-
-    entry.on('resume', function (who) {
-      if (self._paused && !entry._disowned) {
-        self.resume(who)
-      }
-    })
-
-    entry.on('stat', function (props) {
-      self.emit('_entryStat', entry, props)
-      if (entry._aborted) return
-      if (entry._paused) {
-        entry.once('resume', function () {
-          self.emit('entryStat', entry, props)
-        })
-      } else self.emit('entryStat', entry, props)
-    })
-
-    entry.on('ready', function EMITCHILD () {
-      // console.error("DR emit child", entry._path)
-      if (self._paused) {
-        // console.error("  DR emit child - try again later")
-        // pause the child, and emit the "entry" event once we drain.
-        // console.error("DR pausing child entry")
-        entry.pause(self)
-        return self.once('resume', EMITCHILD)
-      }
-
-      // skip over sockets.  they can't be piped around properly,
-      // so there's really no sense even acknowledging them.
-      // if someone really wants to see them, they can listen to
-      // the "socket" events.
-      if (entry.type === 'Socket') {
-        self.emit('socket', entry)
-      } else {
-        self.emitEntry(entry)
-      }
-    })
-
-    var ended = false
-    entry.on('close', onend)
-    entry.on('disown', onend)
-    function onend () {
-      if (ended) return
-      ended = true
-      self.emit('childEnd', entry)
-      self.emit('entryEnd', entry)
-      self._currentEntry = null
-      if (!self._paused) {
-        self._read()
-      }
-    }
-
-    // XXX Remove this.  Works in node as of 0.6.2 or so.
-    // Long filenames should not break stuff.
-    entry.on('error', function (er) {
-      if (entry._swallowErrors) {
-        self.warn(er)
-        entry.emit('end')
-        entry.emit('close')
-      } else {
-        self.emit('error', er)
-      }
-    })
-
-    // proxy up some events.
-    ;[
-      'child',
-      'childEnd',
-      'warn'
-    ].forEach(function (ev) {
-      entry.on(ev, self.emit.bind(self, ev))
-    })
-  })
-}
-
-DirReader.prototype.disown = function (entry) {
-  entry.emit('beforeDisown')
-  entry._disowned = true
-  entry.parent = entry.root = null
-  if (entry === this._currentEntry) {
-    this._currentEntry = null
-  }
-  entry.emit('disown')
-}
-
-DirReader.prototype.getChildProps = function () {
-  return {
-    depth: this.depth + 1,
-    root: this.root || this,
-    parent: this,
-    follow: this.follow,
-    filter: this.filter,
-    sort: this.props.sort,
-    hardlinks: this.props.hardlinks
-  }
-}
-
-DirReader.prototype.pause = function (who) {
-  var self = this
-  if (self._paused) return
-  who = who || self
-  self._paused = true
-  if (self._currentEntry && self._currentEntry.pause) {
-    self._currentEntry.pause(who)
-  }
-  self.emit('pause', who)
-}
-
-DirReader.prototype.resume = function (who) {
-  var self = this
-  if (!self._paused) return
-  who = who || self
-
-  self._paused = false
-  // console.error('DR Emit Resume', self._path)
-  self.emit('resume', who)
-  if (self._paused) {
-    // console.error('DR Re-paused', self._path)
-    return
-  }
-
-  if (self._currentEntry) {
-    if (self._currentEntry.resume) self._currentEntry.resume(who)
-  } else self._read()
-}
-
-DirReader.prototype.emitEntry = function (entry) {
-  this.emit('entry', entry)
-  this.emit('child', entry)
-}

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

@@ -1,174 +0,0 @@
-// It is expected that, when .add() returns false, the consumer
-// of the DirWriter will pause until a "drain" event occurs. Note
-// that this is *almost always going to be the case*, unless the
-// thing being written is some sort of unsupported type, and thus
-// skipped over.
-
-module.exports = DirWriter
-
-var Writer = require('./writer.js')
-var inherits = require('inherits')
-var mkdir = require('mkdirp')
-var path = require('path')
-var collect = require('./collect.js')
-
-inherits(DirWriter, Writer)
-
-function DirWriter (props) {
-  var self = this
-  if (!(self instanceof DirWriter)) {
-    self.error('DirWriter must be called as constructor.', null, true)
-  }
-
-  // should already be established as a Directory type
-  if (props.type !== 'Directory' || !props.Directory) {
-    self.error('Non-directory type ' + props.type + ' ' +
-      JSON.stringify(props), null, true)
-  }
-
-  Writer.call(this, props)
-}
-
-DirWriter.prototype._create = function () {
-  var self = this
-  mkdir(self._path, Writer.dirmode, function (er) {
-    if (er) return self.error(er)
-    // ready to start getting entries!
-    self.ready = true
-    self.emit('ready')
-    self._process()
-  })
-}
-
-// a DirWriter has an add(entry) method, but its .write() doesn't
-// do anything.  Why a no-op rather than a throw?  Because this
-// leaves open the door for writing directory metadata for
-// gnu/solaris style dumpdirs.
-DirWriter.prototype.write = function () {
-  return true
-}
-
-DirWriter.prototype.end = function () {
-  this._ended = true
-  this._process()
-}
-
-DirWriter.prototype.add = function (entry) {
-  var self = this
-
-  // console.error('\tadd', entry._path, '->', self._path)
-  collect(entry)
-  if (!self.ready || self._currentEntry) {
-    self._buffer.push(entry)
-    return false
-  }
-
-  // create a new writer, and pipe the incoming entry into it.
-  if (self._ended) {
-    return self.error('add after end')
-  }
-
-  self._buffer.push(entry)
-  self._process()
-
-  return this._buffer.length === 0
-}
-
-DirWriter.prototype._process = function () {
-  var self = this
-
-  // console.error('DW Process p=%j', self._processing, self.basename)
-
-  if (self._processing) return
-
-  var entry = self._buffer.shift()
-  if (!entry) {
-    // console.error("DW Drain")
-    self.emit('drain')
-    if (self._ended) self._finish()
-    return
-  }
-
-  self._processing = true
-  // console.error("DW Entry", entry._path)
-
-  self.emit('entry', entry)
-
-  // ok, add this entry
-  //
-  // don't allow recursive copying
-  var p = entry
-  var pp
-  do {
-    pp = p._path || p.path
-    if (pp === self.root._path || pp === self._path ||
-      (pp && pp.indexOf(self._path) === 0)) {
-      // console.error('DW Exit (recursive)', entry.basename, self._path)
-      self._processing = false
-      if (entry._collected) entry.pipe()
-      return self._process()
-    }
-    p = p.parent
-  } while (p)
-
-  // console.error("DW not recursive")
-
-  // chop off the entry's root dir, replace with ours
-  var props = {
-    parent: self,
-    root: self.root || self,
-    type: entry.type,
-    depth: self.depth + 1
-  }
-
-  pp = entry._path || entry.path || entry.props.path
-  if (entry.parent) {
-    pp = pp.substr(entry.parent._path.length + 1)
-  }
-  // get rid of any ../../ shenanigans
-  props.path = path.join(self.path, path.join('/', pp))
-
-  // if i have a filter, the child should inherit it.
-  props.filter = self.filter
-
-  // all the rest of the stuff, copy over from the source.
-  Object.keys(entry.props).forEach(function (k) {
-    if (!props.hasOwnProperty(k)) {
-      props[k] = entry.props[k]
-    }
-  })
-
-  // not sure at this point what kind of writer this is.
-  var child = self._currentChild = new Writer(props)
-  child.on('ready', function () {
-    // console.error("DW Child Ready", child.type, child._path)
-    // console.error("  resuming", entry._path)
-    entry.pipe(child)
-    entry.resume()
-  })
-
-  // XXX Make this work in node.
-  // Long filenames should not break stuff.
-  child.on('error', function (er) {
-    if (child._swallowErrors) {
-      self.warn(er)
-      child.emit('end')
-      child.emit('close')
-    } else {
-      self.emit('error', er)
-    }
-  })
-
-  // we fire _end internally *after* end, so that we don't move on
-  // until any "end" listeners have had their chance to do stuff.
-  child.on('close', onend)
-  var ended = false
-  function onend () {
-    if (ended) return
-    ended = true
-    // console.error("* DW Child end", child.basename)
-    self._currentChild = null
-    self._processing = false
-    self._process()
-  }
-}

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

@@ -1,150 +0,0 @@
-// Basically just a wrapper around an fs.ReadStream
-
-module.exports = FileReader
-
-var fs = require('graceful-fs')
-var inherits = require('inherits')
-var Reader = require('./reader.js')
-var EOF = {EOF: true}
-var CLOSE = {CLOSE: true}
-
-inherits(FileReader, Reader)
-
-function FileReader (props) {
-  // console.error("    FR create", props.path, props.size, new Error().stack)
-  var self = this
-  if (!(self 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)
-  }
-
-  self._buffer = []
-  self._bytesEmitted = 0
-  Reader.call(self, props)
-}
-
-FileReader.prototype._getStream = function () {
-  var self = this
-  var stream = self._stream = fs.createReadStream(self._path, self.props)
-
-  if (self.props.blksize) {
-    stream.bufferSize = self.props.blksize
-  }
-
-  stream.on('open', self.emit.bind(self, 'open'))
-
-  stream.on('data', function (c) {
-    // console.error('\t\t%d %s', c.length, self.basename)
-    self._bytesEmitted += c.length
-    // no point saving empty chunks
-    if (!c.length) {
-      return
-    } else if (self._paused || self._buffer.length) {
-      self._buffer.push(c)
-      self._read()
-    } else self.emit('data', c)
-  })
-
-  stream.on('end', function () {
-    if (self._paused || self._buffer.length) {
-      // console.error('FR Buffering End', self._path)
-      self._buffer.push(EOF)
-      self._read()
-    } else {
-      self.emit('end')
-    }
-
-    if (self._bytesEmitted !== self.props.size) {
-      self.error("Didn't get expected byte count\n" +
-        'expect: ' + self.props.size + '\n' +
-        'actual: ' + self._bytesEmitted)
-    }
-  })
-
-  stream.on('close', function () {
-    if (self._paused || self._buffer.length) {
-      // console.error('FR Buffering Close', self._path)
-      self._buffer.push(CLOSE)
-      self._read()
-    } else {
-      // console.error('FR close 1', self._path)
-      self.emit('close')
-    }
-  })
-
-  stream.on('error', function (e) {
-    self.emit('error', e)
-  })
-
-  self._read()
-}
-
-FileReader.prototype._read = function () {
-  var self = this
-  // console.error('FR _read', self._path)
-  if (self._paused) {
-    // console.error('FR _read paused', self._path)
-    return
-  }
-
-  if (!self._stream) {
-    // console.error('FR _getStream calling', self._path)
-    return self._getStream()
-  }
-
-  // clear out the buffer, if there is one.
-  if (self._buffer.length) {
-    // console.error('FR _read has buffer', self._buffer.length, self._path)
-    var buf = self._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', self._path)
-        self.emit('end')
-      } else if (c === CLOSE) {
-        // console.error('FR Read emitting buffered close', self._path)
-        self.emit('close')
-      } else {
-        // console.error('FR Read emitting buffered data', self._path)
-        self.emit('data', c)
-      }
-
-      if (self._paused) {
-        // console.error('FR Read Re-pausing at '+i, self._path)
-        self._buffer = buf.slice(i)
-        return
-      }
-    }
-    self._buffer.length = 0
-  }
-// console.error("FR _read done")
-// that's about all there is to it.
-}
-
-FileReader.prototype.pause = function (who) {
-  var self = this
-  // console.error('FR Pause', self._path)
-  if (self._paused) return
-  who = who || self
-  self._paused = true
-  if (self._stream) self._stream.pause()
-  self.emit('pause', who)
-}
-
-FileReader.prototype.resume = function (who) {
-  var self = this
-  // console.error('FR Resume', self._path)
-  if (!self._paused) return
-  who = who || self
-  self.emit('resume', who)
-  self._paused = false
-  if (self._stream) self._stream.resume()
-  self._read()
-}

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

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

package/node_modules/fstream/lib/get-type.js

@@ -1,33 +0,0 @@
-module.exports = getType
-
-function getType (st) {
-  var types = [
-    'Directory',
-    'File',
-    'SymbolicLink',
-    'Link', // special for hardlinks from tarballs
-    'BlockDevice',
-    'CharacterDevice',
-    'FIFO',
-    'Socket'
-  ]
-  var type
-
-  if (st.type && types.indexOf(st.type) !== -1) {
-    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
-}