fsevents 0.3.8 → 1.0.0

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

@@ -0,0 +1,385 @@
+// parse a 512-byte header block to a data object, or vice-versa
+// If the data won't fit nicely in a simple header, then generate
+// the appropriate extended header file, and return that.
+
+module.exports = TarHeader
+
+var tar = require("../tar.js")
+  , fields = tar.fields
+  , fieldOffs = tar.fieldOffs
+  , fieldEnds = tar.fieldEnds
+  , fieldSize = tar.fieldSize
+  , numeric = tar.numeric
+  , assert = require("assert").ok
+  , space = " ".charCodeAt(0)
+  , slash = "/".charCodeAt(0)
+  , bslash = process.platform === "win32" ? "\\".charCodeAt(0) : null
+
+function TarHeader (block) {
+  if (!(this instanceof TarHeader)) return new TarHeader(block)
+  if (block) this.decode(block)
+}
+
+TarHeader.prototype =
+  { decode : decode
+  , encode: encode
+  , calcSum: calcSum
+  , checkSum: checkSum
+  }
+
+TarHeader.parseNumeric = parseNumeric
+TarHeader.encode = encode
+TarHeader.decode = decode
+
+// note that this will only do the normal ustar header, not any kind
+// of extended posix header file.  If something doesn't fit comfortably,
+// then it will set obj.needExtended = true, and set the block to
+// the closest approximation.
+function encode (obj) {
+  if (!obj && !(this instanceof TarHeader)) throw new Error(
+    "encode must be called on a TarHeader, or supplied an object")
+
+  obj = obj || this
+  var block = obj.block = new Buffer(512)
+
+  // if the object has a "prefix", then that's actually an extension of
+  // the path field.
+  if (obj.prefix) {
+    // console.error("%% header encoding, got a prefix", obj.prefix)
+    obj.path = obj.prefix + "/" + obj.path
+    // console.error("%% header encoding, prefixed path", obj.path)
+    obj.prefix = ""
+  }
+
+  obj.needExtended = false
+
+  if (obj.mode) {
+    if (typeof obj.mode === "string") obj.mode = parseInt(obj.mode, 8)
+    obj.mode = obj.mode & 0777
+  }
+
+  for (var f = 0; fields[f] !== null; f ++) {
+    var field = fields[f]
+      , off = fieldOffs[f]
+      , end = fieldEnds[f]
+      , ret
+
+    switch (field) {
+      case "cksum":
+        // special, done below, after all the others
+        break
+
+      case "prefix":
+        // special, this is an extension of the "path" field.
+        // console.error("%% header encoding, skip prefix later")
+        break
+
+      case "type":
+        // convert from long name to a single char.
+        var type = obj.type || "0"
+        if (type.length > 1) {
+          type = tar.types[obj.type]
+          if (!type) type = "0"
+        }
+        writeText(block, off, end, type)
+        break
+
+      case "path":
+        // uses the "prefix" field if > 100 bytes, but <= 255
+        var pathLen = Buffer.byteLength(obj.path)
+          , pathFSize = fieldSize[fields.path]
+          , prefFSize = fieldSize[fields.prefix]
+
+        // paths between 100 and 255 should use the prefix field.
+        // longer than 255
+        if (pathLen > pathFSize &&
+            pathLen <= pathFSize + prefFSize) {
+          // need to find a slash somewhere in the middle so that
+          // path and prefix both fit in their respective fields
+          var searchStart = pathLen - 1 - pathFSize
+            , searchEnd = prefFSize
+            , found = false
+            , pathBuf = new Buffer(obj.path)
+
+          for ( var s = searchStart
+              ; (s <= searchEnd)
+              ; s ++ ) {
+            if (pathBuf[s] === slash || pathBuf[s] === bslash) {
+              found = s
+              break
+            }
+          }
+
+          if (found !== false) {
+            prefix = pathBuf.slice(0, found).toString("utf8")
+            path = pathBuf.slice(found + 1).toString("utf8")
+
+            ret = writeText(block, off, end, path)
+            off = fieldOffs[fields.prefix]
+            end = fieldEnds[fields.prefix]
+            // console.error("%% header writing prefix", off, end, prefix)
+            ret = writeText(block, off, end, prefix) || ret
+            break
+          }
+        }
+
+        // paths less than 100 chars don't need a prefix
+        // and paths longer than 255 need an extended header and will fail
+        // on old implementations no matter what we do here.
+        // Null out the prefix, and fallthrough to default.
+        // console.error("%% header writing no prefix")
+        var poff = fieldOffs[fields.prefix]
+          , pend = fieldEnds[fields.prefix]
+        writeText(block, poff, pend, "")
+        // fallthrough
+
+      // all other fields are numeric or text
+      default:
+        ret = numeric[field]
+            ? writeNumeric(block, off, end, obj[field])
+            : writeText(block, off, end, obj[field] || "")
+        break
+    }
+    obj.needExtended = obj.needExtended || ret
+  }
+
+  var off = fieldOffs[fields.cksum]
+    , end = fieldEnds[fields.cksum]
+
+  writeNumeric(block, off, end, calcSum.call(this, block))
+
+  return block
+}
+
+// if it's a negative number, or greater than will fit,
+// then use write256.
+var MAXNUM = { 12: 077777777777
+             , 11: 07777777777
+             , 8 : 07777777
+             , 7 : 0777777 }
+function writeNumeric (block, off, end, num) {
+  var writeLen = end - off
+    , maxNum = MAXNUM[writeLen] || 0
+
+  num = num || 0
+  // console.error("  numeric", num)
+
+  if (num instanceof Date ||
+      Object.prototype.toString.call(num) === "[object Date]") {
+    num = num.getTime() / 1000
+  }
+
+  if (num > maxNum || num < 0) {
+    write256(block, off, end, num)
+    // need an extended header if negative or too big.
+    return true
+  }
+
+  // god, tar is so annoying
+  // if the string is small enough, you should put a space
+  // between the octal string and the \0, but if it doesn't
+  // fit, then don't.
+  var numStr = Math.floor(num).toString(8)
+  if (num < MAXNUM[writeLen - 1]) numStr += " "
+
+  // pad with "0" chars
+  if (numStr.length < writeLen) {
+    numStr = (new Array(writeLen - numStr.length).join("0")) + numStr
+  }
+
+  if (numStr.length !== writeLen - 1) {
+    throw new Error("invalid length: " + JSON.stringify(numStr) + "\n" +
+                    "expected: "+writeLen)
+  }
+  block.write(numStr, off, writeLen, "utf8")
+  block[end - 1] = 0
+}
+
+function write256 (block, off, end, num) {
+  var buf = block.slice(off, end)
+  var positive = num >= 0
+  buf[0] = positive ? 0x80 : 0xFF
+
+  // get the number as a base-256 tuple
+  if (!positive) num *= -1
+  var tuple = []
+  do {
+    var n = num % 256
+    tuple.push(n)
+    num = (num - n) / 256
+  } while (num)
+
+  var bytes = tuple.length
+
+  var fill = buf.length - bytes
+  for (var i = 1; i < fill; i ++) {
+    buf[i] = positive ? 0 : 0xFF
+  }
+
+  // tuple is a base256 number, with [0] as the *least* significant byte
+  // if it's negative, then we need to flip all the bits once we hit the
+  // first non-zero bit.  The 2's-complement is (0x100 - n), and the 1's-
+  // complement is (0xFF - n).
+  var zero = true
+  for (i = bytes; i > 0; i --) {
+    var byte = tuple[bytes - i]
+    if (positive) buf[fill + i] = byte
+    else if (zero && byte === 0) buf[fill + i] = 0
+    else if (zero) {
+      zero = false
+      buf[fill + i] = 0x100 - byte
+    } else buf[fill + i] = 0xFF - byte
+  }
+}
+
+function writeText (block, off, end, str) {
+  // strings are written as utf8, then padded with \0
+  var strLen = Buffer.byteLength(str)
+    , writeLen = Math.min(strLen, end - off)
+    // non-ascii fields need extended headers
+    // long fields get truncated
+    , needExtended = strLen !== str.length || strLen > writeLen
+
+  // write the string, and null-pad
+  if (writeLen > 0) block.write(str, off, writeLen, "utf8")
+  for (var i = off + writeLen; i < end; i ++) block[i] = 0
+
+  return needExtended
+}
+
+function calcSum (block) {
+  block = block || this.block
+  assert(Buffer.isBuffer(block) && block.length === 512)
+
+  if (!block) throw new Error("Need block to checksum")
+
+  // now figure out what it would be if the cksum was "        "
+  var sum = 0
+    , start = fieldOffs[fields.cksum]
+    , end = fieldEnds[fields.cksum]
+
+  for (var i = 0; i < fieldOffs[fields.cksum]; i ++) {
+    sum += block[i]
+  }
+
+  for (var i = start; i < end; i ++) {
+    sum += space
+  }
+
+  for (var i = end; i < 512; i ++) {
+    sum += block[i]
+  }
+
+  return sum
+}
+
+
+function checkSum (block) {
+  var sum = calcSum.call(this, block)
+  block = block || this.block
+
+  var cksum = block.slice(fieldOffs[fields.cksum], fieldEnds[fields.cksum])
+  cksum = parseNumeric(cksum)
+
+  return cksum === sum
+}
+
+function decode (block) {
+  block = block || this.block
+  assert(Buffer.isBuffer(block) && block.length === 512)
+
+  this.block = block
+  this.cksumValid = this.checkSum()
+
+  var prefix = null
+
+  // slice off each field.
+  for (var f = 0; fields[f] !== null; f ++) {
+    var field = fields[f]
+      , val = block.slice(fieldOffs[f], fieldEnds[f])
+
+    switch (field) {
+      case "ustar":
+        // if not ustar, then everything after that is just padding.
+        if (val.toString() !== "ustar\0") {
+          this.ustar = false
+          return
+        } else {
+          // console.error("ustar:", val, val.toString())
+          this.ustar = val.toString()
+        }
+        break
+
+      // prefix is special, since it might signal the xstar header
+      case "prefix":
+        var atime = parseNumeric(val.slice(131, 131 + 12))
+          , ctime = parseNumeric(val.slice(131 + 12, 131 + 12 + 12))
+        if ((val[130] === 0 || val[130] === space) &&
+            typeof atime === "number" &&
+            typeof ctime === "number" &&
+            val[131 + 12] === space &&
+            val[131 + 12 + 12] === space) {
+          this.atime = atime
+          this.ctime = ctime
+          val = val.slice(0, 130)
+        }
+        prefix = val.toString("utf8").replace(/\0+$/, "")
+        // console.error("%% header reading prefix", prefix)
+        break
+
+      // all other fields are null-padding text
+      // or a number.
+      default:
+        if (numeric[field]) {
+          this[field] = parseNumeric(val)
+        } else {
+          this[field] = val.toString("utf8").replace(/\0+$/, "")
+        }
+        break
+    }
+  }
+
+  // if we got a prefix, then prepend it to the path.
+  if (prefix) {
+    this.path = prefix + "/" + this.path
+    // console.error("%% header got a prefix", this.path)
+  }
+}
+
+function parse256 (buf) {
+  // first byte MUST be either 80 or FF
+  // 80 for positive, FF for 2's comp
+  var positive
+  if (buf[0] === 0x80) positive = true
+  else if (buf[0] === 0xFF) positive = false
+  else return null
+
+  // build up a base-256 tuple from the least sig to the highest
+  var zero = false
+    , tuple = []
+  for (var i = buf.length - 1; i > 0; i --) {
+    var byte = buf[i]
+    if (positive) tuple.push(byte)
+    else if (zero && byte === 0) tuple.push(0)
+    else if (zero) {
+      zero = false
+      tuple.push(0x100 - byte)
+    } else tuple.push(0xFF - byte)
+  }
+
+  for (var sum = 0, i = 0, l = tuple.length; i < l; i ++) {
+    sum += tuple[i] * Math.pow(256, i)
+  }
+
+  return positive ? sum : -1 * sum
+}
+
+function parseNumeric (f) {
+  if (f[0] & 0x80) return parse256(f)
+
+  var str = f.toString("utf8").split("\0")[0].trim()
+    , res = parseInt(str, 8)
+
+  return isNaN(res) ? null : res
+}
+

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

@@ -0,0 +1,236 @@
+// pipe in an fstream, and it'll make a tarball.
+// key-value pair argument is global extended header props.
+
+module.exports = Pack
+
+var EntryWriter = require("./entry-writer.js")
+  , Stream = require("stream").Stream
+  , path = require("path")
+  , inherits = require("inherits")
+  , GlobalHeaderWriter = require("./global-header-writer.js")
+  , collect = require("fstream").collect
+  , eof = new Buffer(512)
+
+for (var i = 0; i < 512; i ++) eof[i] = 0
+
+inherits(Pack, Stream)
+
+function Pack (props) {
+  // console.error("-- p ctor")
+  var me = this
+  if (!(me instanceof Pack)) return new Pack(props)
+
+  if (props) me._noProprietary = props.noProprietary
+  else me._noProprietary = false
+
+  me._global = props
+
+  me.readable = true
+  me.writable = true
+  me._buffer = []
+  // console.error("-- -- set current to null in ctor")
+  me._currentEntry = null
+  me._processing = false
+
+  me._pipeRoot = null
+  me.on("pipe", function (src) {
+    if (src.root === me._pipeRoot) return
+    me._pipeRoot = src
+    src.on("end", function () {
+      me._pipeRoot = null
+    })
+    me.add(src)
+  })
+}
+
+Pack.prototype.addGlobal = function (props) {
+  // console.error("-- p addGlobal")
+  if (this._didGlobal) return
+  this._didGlobal = true
+
+  var me = this
+  GlobalHeaderWriter(props)
+    .on("data", function (c) {
+      me.emit("data", c)
+    })
+    .end()
+}
+
+Pack.prototype.add = function (stream) {
+  if (this._global && !this._didGlobal) this.addGlobal(this._global)
+
+  if (this._ended) return this.emit("error", new Error("add after end"))
+
+  collect(stream)
+  this._buffer.push(stream)
+  this._process()
+  this._needDrain = this._buffer.length > 0
+  return !this._needDrain
+}
+
+Pack.prototype.pause = function () {
+  this._paused = true
+  if (this._currentEntry) this._currentEntry.pause()
+  this.emit("pause")
+}
+
+Pack.prototype.resume = function () {
+  this._paused = false
+  if (this._currentEntry) this._currentEntry.resume()
+  this.emit("resume")
+  this._process()
+}
+
+Pack.prototype.end = function () {
+  this._ended = true
+  this._buffer.push(eof)
+  this._process()
+}
+
+Pack.prototype._process = function () {
+  var me = this
+  if (me._paused || me._processing) {
+    return
+  }
+
+  var entry = me._buffer.shift()
+
+  if (!entry) {
+    if (me._needDrain) {
+      me.emit("drain")
+    }
+    return
+  }
+
+  if (entry.ready === false) {
+    // console.error("-- entry is not ready", entry)
+    me._buffer.unshift(entry)
+    entry.on("ready", function () {
+      // console.error("-- -- ready!", entry)
+      me._process()
+    })
+    return
+  }
+
+  me._processing = true
+
+  if (entry === eof) {
+    // need 2 ending null blocks.
+    me.emit("data", eof)
+    me.emit("data", eof)
+    me.emit("end")
+    me.emit("close")
+    return
+  }
+
+  // Change the path to be relative to the root dir that was
+  // added to the tarball.
+  //
+  // XXX This should be more like how -C works, so you can
+  // explicitly set a root dir, and also explicitly set a pathname
+  // in the tarball to use.  That way we can skip a lot of extra
+  // work when resolving symlinks for bundled dependencies in npm.
+
+  var root = path.dirname((entry.root || entry).path);
+  if (me._global && me._global.fromBase && entry.root && entry.root.path) {
+    // user set 'fromBase: true' indicating tar root should be directory itself
+    root = entry.root.path;
+  }
+
+  var wprops = {}
+
+  Object.keys(entry.props || {}).forEach(function (k) {
+    wprops[k] = entry.props[k]
+  })
+
+  if (me._noProprietary) wprops.noProprietary = true
+
+  wprops.path = path.relative(root, entry.path || '')
+
+  // actually not a matter of opinion or taste.
+  if (process.platform === "win32") {
+    wprops.path = wprops.path.replace(/\\/g, "/")
+  }
+
+  if (!wprops.type)
+    wprops.type = 'Directory'
+
+  switch (wprops.type) {
+    // sockets not supported
+    case "Socket":
+      return
+
+    case "Directory":
+      wprops.path += "/"
+      wprops.size = 0
+      break
+
+    case "Link":
+      var lp = path.resolve(path.dirname(entry.path), entry.linkpath)
+      wprops.linkpath = path.relative(root, lp) || "."
+      wprops.size = 0
+      break
+
+    case "SymbolicLink":
+      var lp = path.resolve(path.dirname(entry.path), entry.linkpath)
+      wprops.linkpath = path.relative(path.dirname(entry.path), lp) || "."
+      wprops.size = 0
+      break
+  }
+
+  // console.error("-- new writer", wprops)
+  // if (!wprops.type) {
+  //   // console.error("-- no type?", entry.constructor.name, entry)
+  // }
+
+  // console.error("-- -- set current to new writer", wprops.path)
+  var writer = me._currentEntry = EntryWriter(wprops)
+
+  writer.parent = me
+
+  // writer.on("end", function () {
+  //   // console.error("-- -- writer end", writer.path)
+  // })
+
+  writer.on("data", function (c) {
+    me.emit("data", c)
+  })
+
+  writer.on("header", function () {
+    Buffer.prototype.toJSON = function () {
+      return this.toString().split(/\0/).join(".")
+    }
+    // console.error("-- -- writer header %j", writer.props)
+    if (writer.props.size === 0) nextEntry()
+  })
+  writer.on("close", nextEntry)
+
+  var ended = false
+  function nextEntry () {
+    if (ended) return
+    ended = true
+
+    // console.error("-- -- writer close", writer.path)
+    // console.error("-- -- set current to null", wprops.path)
+    me._currentEntry = null
+    me._processing = false
+    me._process()
+  }
+
+  writer.on("error", function (er) {
+    // console.error("-- -- writer error", writer.path)
+    me.emit("error", er)
+  })
+
+  // if it's the root, then there's no need to add its entries,
+  // or data, since they'll be added directly.
+  if (entry === me._pipeRoot) {
+    // console.error("-- is the root, don't auto-add")
+    writer.add = null
+  }
+
+  entry.pipe(writer)
+}
+
+Pack.prototype.destroy = function () {}
+Pack.prototype.write = function () {}