fsevents 0.3.8 → 1.0.0

package/node_modules/node-pre-gyp/node_modules/tar/lib/entry.js

@@ -0,0 +1,213 @@
+// A passthrough read/write stream that sets its properties
+// based on a header, extendedHeader, and globalHeader
+//
+// Can be either a file system object of some sort, or
+// a pax/ustar metadata entry.
+
+module.exports = Entry
+
+var TarHeader = require("./header.js")
+  , tar = require("../tar")
+  , assert = require("assert").ok
+  , Stream = require("stream").Stream
+  , inherits = require("inherits")
+  , fstream = require("fstream").Abstract
+
+function Entry (header, extended, global) {
+  Stream.call(this)
+  this.readable = true
+  this.writable = true
+
+  this._needDrain = false
+  this._paused = false
+  this._reading = false
+  this._ending = false
+  this._ended = false
+  this._remaining = 0
+  this._queue = []
+  this._index = 0
+  this._queueLen = 0
+
+  this._read = this._read.bind(this)
+
+  this.props = {}
+  this._header = header
+  this._extended = extended || {}
+
+  // globals can change throughout the course of
+  // a file parse operation.  Freeze it at its current state.
+  this._global = {}
+  var me = this
+  Object.keys(global || {}).forEach(function (g) {
+    me._global[g] = global[g]
+  })
+
+  this._setProps()
+}
+
+inherits(Entry, Stream)
+
+Entry.prototype.write = function (c) {
+  if (this._ending) this.error("write() after end()", null, true)
+  if (this._remaining === 0) {
+    this.error("invalid bytes past eof")
+  }
+
+  // often we'll get a bunch of \0 at the end of the last write,
+  // since chunks will always be 512 bytes when reading a tarball.
+  if (c.length > this._remaining) {
+    c = c.slice(0, this._remaining)
+  }
+  this._remaining -= c.length
+
+  // put it on the stack.
+  var ql = this._queueLen
+  this._queue.push(c)
+  this._queueLen ++
+
+  this._read()
+
+  // either paused, or buffered
+  if (this._paused || ql > 0) {
+    this._needDrain = true
+    return false
+  }
+
+  return true
+}
+
+Entry.prototype.end = function (c) {
+  if (c) this.write(c)
+  this._ending = true
+  this._read()
+}
+
+Entry.prototype.pause = function () {
+  this._paused = true
+  this.emit("pause")
+}
+
+Entry.prototype.resume = function () {
+  // console.error("    Tar Entry resume", this.path)
+  this.emit("resume")
+  this._paused = false
+  this._read()
+  return this._queueLen - this._index > 1
+}
+
+  // This is bound to the instance
+Entry.prototype._read = function () {
+  // console.error("    Tar Entry _read", this.path)
+
+  if (this._paused || this._reading || this._ended) return
+
+  // set this flag so that event handlers don't inadvertently
+  // get multiple _read() calls running.
+  this._reading = true
+
+  // have any data to emit?
+  while (this._index < this._queueLen && !this._paused) {
+    var chunk = this._queue[this._index ++]
+    this.emit("data", chunk)
+  }
+
+  // check if we're drained
+  if (this._index >= this._queueLen) {
+    this._queue.length = this._queueLen = this._index = 0
+    if (this._needDrain) {
+      this._needDrain = false
+      this.emit("drain")
+    }
+    if (this._ending) {
+      this._ended = true
+      this.emit("end")
+    }
+  }
+
+  // if the queue gets too big, then pluck off whatever we can.
+  // this should be fairly rare.
+  var mql = this._maxQueueLen
+  if (this._queueLen > mql && this._index > 0) {
+    mql = Math.min(this._index, mql)
+    this._index -= mql
+    this._queueLen -= mql
+    this._queue = this._queue.slice(mql)
+  }
+
+  this._reading = false
+}
+
+Entry.prototype._setProps = function () {
+  // props = extended->global->header->{}
+  var header = this._header
+    , extended = this._extended
+    , global = this._global
+    , props = this.props
+
+  // first get the values from the normal header.
+  var fields = tar.fields
+  for (var f = 0; fields[f] !== null; f ++) {
+    var field = fields[f]
+      , val = header[field]
+    if (typeof val !== "undefined") props[field] = val
+  }
+
+  // next, the global header for this file.
+  // numeric values, etc, will have already been parsed.
+  ;[global, extended].forEach(function (p) {
+    Object.keys(p).forEach(function (f) {
+      if (typeof p[f] !== "undefined") props[f] = p[f]
+    })
+  })
+
+  // no nulls allowed in path or linkpath
+  ;["path", "linkpath"].forEach(function (p) {
+    if (props.hasOwnProperty(p)) {
+      props[p] = props[p].split("\0")[0]
+    }
+  })
+
+
+  // set date fields to be a proper date
+  ;["mtime", "ctime", "atime"].forEach(function (p) {
+    if (props.hasOwnProperty(p)) {
+      props[p] = new Date(props[p] * 1000)
+    }
+  })
+
+  // set the type so that we know what kind of file to create
+  var type
+  switch (tar.types[props.type]) {
+    case "OldFile":
+    case "ContiguousFile":
+      type = "File"
+      break
+
+    case "GNUDumpDir":
+      type = "Directory"
+      break
+
+    case undefined:
+      type = "Unknown"
+      break
+
+    case "Link":
+    case "SymbolicLink":
+    case "CharacterDevice":
+    case "BlockDevice":
+    case "Directory":
+    case "FIFO":
+    default:
+      type = tar.types[props.type]
+  }
+
+  this.type = type
+  this.path = props.path
+  this.size = props.size
+
+  // size is special, since it signals when the file needs to end.
+  this._remaining = props.size
+}
+
+Entry.prototype.warn = fstream.warn
+Entry.prototype.error = fstream.error

package/node_modules/node-pre-gyp/node_modules/tar/lib/extended-header-writer.js

@@ -0,0 +1,191 @@
+
+module.exports = ExtendedHeaderWriter
+
+var inherits = require("inherits")
+  , EntryWriter = require("./entry-writer.js")
+
+inherits(ExtendedHeaderWriter, EntryWriter)
+
+var tar = require("../tar.js")
+  , path = require("path")
+  , TarHeader = require("./header.js")
+
+// props is the props of the thing we need to write an
+// extended header for.
+// Don't be shy with it.  Just encode everything.
+function ExtendedHeaderWriter (props) {
+  // console.error(">> ehw ctor")
+  var me = this
+
+  if (!(me instanceof ExtendedHeaderWriter)) {
+    return new ExtendedHeaderWriter(props)
+  }
+
+  me.fields = props
+
+  var p =
+    { path : ("PaxHeader" + path.join("/", props.path || ""))
+             .replace(/\\/g, "/").substr(0, 100)
+    , mode : props.mode || 0666
+    , uid : props.uid || 0
+    , gid : props.gid || 0
+    , size : 0 // will be set later
+    , mtime : props.mtime || Date.now() / 1000
+    , type : "x"
+    , linkpath : ""
+    , ustar : "ustar\0"
+    , ustarver : "00"
+    , uname : props.uname || ""
+    , gname : props.gname || ""
+    , devmaj : props.devmaj || 0
+    , devmin : props.devmin || 0
+    }
+
+
+  EntryWriter.call(me, p)
+  // console.error(">> ehw props", me.props)
+  me.props = p
+
+  me._meta = true
+}
+
+ExtendedHeaderWriter.prototype.end = function () {
+  // console.error(">> ehw end")
+  var me = this
+
+  if (me._ended) return
+  me._ended = true
+
+  me._encodeFields()
+
+  if (me.props.size === 0) {
+    // nothing to write!
+    me._ready = true
+    me._stream.end()
+    return
+  }
+
+  me._stream.write(TarHeader.encode(me.props))
+  me.body.forEach(function (l) {
+    me._stream.write(l)
+  })
+  me._ready = true
+
+  // console.error(">> ehw _process calling end()", me.props)
+  this._stream.end()
+}
+
+ExtendedHeaderWriter.prototype._encodeFields = function () {
+  // console.error(">> ehw _encodeFields")
+  this.body = []
+  if (this.fields.prefix) {
+    this.fields.path = this.fields.prefix + "/" + this.fields.path
+    this.fields.prefix = ""
+  }
+  encodeFields(this.fields, "", this.body, this.fields.noProprietary)
+  var me = this
+  this.body.forEach(function (l) {
+    me.props.size += l.length
+  })
+}
+
+function encodeFields (fields, prefix, body, nop) {
+  // console.error(">> >> ehw encodeFields")
+  // "%d %s=%s\n", <length>, <keyword>, <value>
+  // The length is a decimal number, and includes itself and the \n
+  // Numeric values are decimal strings.
+
+  Object.keys(fields).forEach(function (k) {
+    var val = fields[k]
+      , numeric = tar.numeric[k]
+
+    if (prefix) k = prefix + "." + k
+
+    // already including NODETAR.type, don't need File=true also
+    if (k === fields.type && val === true) return
+
+    switch (k) {
+      // don't include anything that's always handled just fine
+      // in the normal header, or only meaningful in the context
+      // of nodetar
+      case "mode":
+      case "cksum":
+      case "ustar":
+      case "ustarver":
+      case "prefix":
+      case "basename":
+      case "dirname":
+      case "needExtended":
+      case "block":
+      case "filter":
+        return
+
+      case "rdev":
+        if (val === 0) return
+        break
+
+      case "nlink":
+      case "dev": // Truly a hero among men, Creator of Star!
+      case "ino": // Speak his name with reverent awe!  It is:
+        k = "SCHILY." + k
+        break
+
+      default: break
+    }
+
+    if (val && typeof val === "object" &&
+        !Buffer.isBuffer(val)) encodeFields(val, k, body, nop)
+    else if (val === null || val === undefined) return
+    else body.push.apply(body, encodeField(k, val, nop))
+  })
+
+  return body
+}
+
+function encodeField (k, v, nop) {
+  // lowercase keys must be valid, otherwise prefix with
+  // "NODETAR."
+  if (k.charAt(0) === k.charAt(0).toLowerCase()) {
+    var m = k.split(".")[0]
+    if (!tar.knownExtended[m]) k = "NODETAR." + k
+  }
+
+  // no proprietary
+  if (nop && k.charAt(0) !== k.charAt(0).toLowerCase()) {
+    return []
+  }
+
+  if (typeof val === "number") val = val.toString(10)
+
+  var s = new Buffer(" " + k + "=" + v + "\n")
+    , digits = Math.floor(Math.log(s.length) / Math.log(10)) + 1
+
+  // console.error("1 s=%j digits=%j s.length=%d", s.toString(), digits, s.length)
+
+  // if adding that many digits will make it go over that length,
+  // then add one to it. For example, if the string is:
+  // " foo=bar\n"
+  // then that's 9 characters.  With the "9", that bumps the length
+  // up to 10.  However, this is invalid:
+  // "10 foo=bar\n"
+  // but, since that's actually 11 characters, since 10 adds another
+  // character to the length, and the length includes the number
+  // itself.  In that case, just bump it up again.
+  if (s.length + digits >= Math.pow(10, digits)) digits += 1
+  // console.error("2 s=%j digits=%j s.length=%d", s.toString(), digits, s.length)
+
+  var len = digits + s.length
+  // console.error("3 s=%j digits=%j s.length=%d len=%d", s.toString(), digits, s.length, len)
+  var lenBuf = new Buffer("" + len)
+  if (lenBuf.length + s.length !== len) {
+    throw new Error("Bad length calculation\n"+
+                    "len="+len+"\n"+
+                    "lenBuf="+JSON.stringify(lenBuf.toString())+"\n"+
+                    "lenBuf.length="+lenBuf.length+"\n"+
+                    "digits="+digits+"\n"+
+                    "s="+JSON.stringify(s.toString())+"\n"+
+                    "s.length="+s.length)
+  }
+
+  return [lenBuf, s]
+}

package/node_modules/node-pre-gyp/node_modules/tar/lib/extended-header.js

@@ -0,0 +1,140 @@
+// An Entry consisting of:
+//
+// "%d %s=%s\n", <length>, <keyword>, <value>
+//
+// The length is a decimal number, and includes itself and the \n
+// \0 does not terminate anything.  Only the length terminates the string.
+// Numeric values are decimal strings.
+
+module.exports = ExtendedHeader
+
+var Entry = require("./entry.js")
+  , inherits = require("inherits")
+  , tar = require("../tar.js")
+  , numeric = tar.numeric
+  , keyTrans = { "SCHILY.dev": "dev"
+               , "SCHILY.ino": "ino"
+               , "SCHILY.nlink": "nlink" }
+
+function ExtendedHeader () {
+  Entry.apply(this, arguments)
+  this.on("data", this._parse)
+  this.fields = {}
+  this._position = 0
+  this._fieldPos = 0
+  this._state = SIZE
+  this._sizeBuf = []
+  this._keyBuf = []
+  this._valBuf = []
+  this._size = -1
+  this._key = ""
+}
+
+inherits(ExtendedHeader, Entry)
+ExtendedHeader.prototype._parse = parse
+
+var s = 0
+  , states = ExtendedHeader.states = {}
+  , SIZE = states.SIZE = s++
+  , KEY  = states.KEY  = s++
+  , VAL  = states.VAL  = s++
+  , ERR  = states.ERR  = s++
+
+Object.keys(states).forEach(function (s) {
+  states[states[s]] = states[s]
+})
+
+states[s] = null
+
+// char code values for comparison
+var _0 = "0".charCodeAt(0)
+  , _9 = "9".charCodeAt(0)
+  , point = ".".charCodeAt(0)
+  , a = "a".charCodeAt(0)
+  , Z = "Z".charCodeAt(0)
+  , a = "a".charCodeAt(0)
+  , z = "z".charCodeAt(0)
+  , space = " ".charCodeAt(0)
+  , eq = "=".charCodeAt(0)
+  , cr = "\n".charCodeAt(0)
+
+function parse (c) {
+  if (this._state === ERR) return
+
+  for ( var i = 0, l = c.length
+      ; i < l
+      ; this._position++, this._fieldPos++, i++) {
+    // console.error("top of loop, size="+this._size)
+
+    var b = c[i]
+
+    if (this._size >= 0 && this._fieldPos > this._size) {
+      error(this, "field exceeds length="+this._size)
+      return
+    }
+
+    switch (this._state) {
+      case ERR: return
+
+      case SIZE:
+        // console.error("parsing size, b=%d, rest=%j", b, c.slice(i).toString())
+        if (b === space) {
+          this._state = KEY
+          // this._fieldPos = this._sizeBuf.length
+          this._size = parseInt(new Buffer(this._sizeBuf).toString(), 10)
+          this._sizeBuf.length = 0
+          continue
+        }
+        if (b < _0 || b > _9) {
+          error(this, "expected [" + _0 + ".." + _9 + "], got " + b)
+          return
+        }
+        this._sizeBuf.push(b)
+        continue
+
+      case KEY:
+        // can be any char except =, not > size.
+        if (b === eq) {
+          this._state = VAL
+          this._key = new Buffer(this._keyBuf).toString()
+          if (keyTrans[this._key]) this._key = keyTrans[this._key]
+          this._keyBuf.length = 0
+          continue
+        }
+        this._keyBuf.push(b)
+        continue
+
+      case VAL:
+        // field must end with cr
+        if (this._fieldPos === this._size - 1) {
+          // console.error("finished with "+this._key)
+          if (b !== cr) {
+            error(this, "expected \\n at end of field")
+            return
+          }
+          var val = new Buffer(this._valBuf).toString()
+          if (numeric[this._key]) {
+            val = parseFloat(val)
+          }
+          this.fields[this._key] = val
+
+          this._valBuf.length = 0
+          this._state = SIZE
+          this._size = -1
+          this._fieldPos = -1
+          continue
+        }
+        this._valBuf.push(b)
+        continue
+    }
+  }
+}
+
+function error (me, msg) {
+  msg = "invalid header: " + msg
+      + "\nposition=" + me._position
+      + "\nfield position=" + me._fieldPos
+
+  me.error(msg)
+  me.state = ERR
+}

package/node_modules/node-pre-gyp/node_modules/tar/lib/extract.js

@@ -0,0 +1,94 @@
+// give it a tarball and a path, and it'll dump the contents
+
+module.exports = Extract
+
+var tar = require("../tar.js")
+  , fstream = require("fstream")
+  , inherits = require("inherits")
+  , path = require("path")
+
+function Extract (opts) {
+  if (!(this instanceof Extract)) return new Extract(opts)
+  tar.Parse.apply(this)
+
+  if (typeof opts !== "object") {
+    opts = { path: opts }
+  }
+
+  // better to drop in cwd? seems more standard.
+  opts.path = opts.path || path.resolve("node-tar-extract")
+  opts.type = "Directory"
+  opts.Directory = true
+
+  // similar to --strip or --strip-components
+  opts.strip = +opts.strip
+  if (!opts.strip || opts.strip <= 0) opts.strip = 0
+
+  this._fst = fstream.Writer(opts)
+
+  this.pause()
+  var me = this
+
+  // Hardlinks in tarballs are relative to the root
+  // of the tarball.  So, they need to be resolved against
+  // the target directory in order to be created properly.
+  me.on("entry", function (entry) {
+    // if there's a "strip" argument, then strip off that many
+    // path components.
+    if (opts.strip) {
+      var p = entry.path.split("/").slice(opts.strip).join("/")
+      entry.path = entry.props.path = p
+      if (entry.linkpath) {
+        var lp = entry.linkpath.split("/").slice(opts.strip).join("/")
+        entry.linkpath = entry.props.linkpath = lp
+      }
+    }
+    if (entry.type === "Link") {
+      entry.linkpath = entry.props.linkpath =
+        path.join(opts.path, path.join("/", entry.props.linkpath))
+    }
+
+    if (entry.type === "SymbolicLink") {
+      var dn = path.dirname(entry.path) || ""
+      var linkpath = entry.props.linkpath
+      var target = path.resolve(opts.path, dn, linkpath)
+      if (target.indexOf(opts.path) !== 0) {
+        linkpath = path.join(opts.path, path.join("/", linkpath))
+      }
+      entry.linkpath = entry.props.linkpath = linkpath
+    }
+  })
+
+  this._fst.on("ready", function () {
+    me.pipe(me._fst, { end: false })
+    me.resume()
+  })
+
+  this._fst.on('error', function(err) {
+    me.emit('error', err)
+  })
+
+  this._fst.on('drain', function() {
+    me.emit('drain')
+  })
+
+  // this._fst.on("end", function () {
+  //   console.error("\nEEEE Extract End", me._fst.path)
+  // })
+
+  this._fst.on("close", function () {
+    // console.error("\nEEEE Extract End", me._fst.path)
+    me.emit("finish")
+    me.emit("end")
+    me.emit("close")
+  })
+}
+
+inherits(Extract, tar.Parse)
+
+Extract.prototype._streamEnd = function () {
+  var me = this
+  if (!me._ended || me._entry) me.error("unexpected eof")
+  me._fst.end()
+  // my .end() is coming later.
+}

package/node_modules/node-pre-gyp/node_modules/tar/lib/global-header-writer.js

@@ -0,0 +1,14 @@
+module.exports = GlobalHeaderWriter
+
+var ExtendedHeaderWriter = require("./extended-header-writer.js")
+  , inherits = require("inherits")
+
+inherits(GlobalHeaderWriter, ExtendedHeaderWriter)
+
+function GlobalHeaderWriter (props) {
+  if (!(this instanceof GlobalHeaderWriter)) {
+    return new GlobalHeaderWriter(props)
+  }
+  ExtendedHeaderWriter.call(this, props)
+  this.props.type = "g"
+}