fsevents 1.2.0 → 1.2.2

package/node_modules/tar/lib/header.js

@@ -1,385 +1,273 @@
+'use strict'
 // 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
+// encode returns `true` if a pax extended header is needed, because
+// the data could not be faithfully encoded in a simple header.
+// (Also, check header.needPax to see if it needs a pax header.)
+
+const Buffer = require('./buffer.js')
+const types = require('./types.js')
+const pathModule = require('path')
+const large = require('./large-numbers.js')
+
+const TYPE = Symbol('type')
+
+class Header {
+  constructor (data, off) {
+    this.cksumValid = false
+    this.needPax = false
+    this.nullBlock = false
+
+    this.block = null
+    this.path = null
+    this.mode = null
+    this.uid = null
+    this.gid = null
+    this.size = null
+    this.mtime = null
+    this.cksum = null
+    this[TYPE] = '0'
+    this.linkpath = null
+    this.uname = null
+    this.gname = null
+    this.devmaj = 0
+    this.devmin = 0
+    this.atime = null
+    this.ctime = null
+
+    if (Buffer.isBuffer(data))
+      this.decode(data, off || 0)
+    else if (data)
+      this.set(data)
   }
 
-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
-  }
+  decode (buf, off) {
+    if (!off)
+      off = 0
+
+    if (!buf || !(buf.length >= off + 512))
+      throw new Error('need 512 bytes for header')
+
+    this.path = decString(buf, off, 100)
+    this.mode = decNumber(buf, off + 100, 8)
+    this.uid = decNumber(buf, off + 108, 8)
+    this.gid = decNumber(buf, off + 116, 8)
+    this.size = decNumber(buf, off + 124, 12)
+    this.mtime = decDate(buf, off + 136, 12)
+    this.cksum = decNumber(buf, off + 148, 12)
+
+    // old tar versions marked dirs as a file with a trailing /
+    this[TYPE] = decString(buf, off + 156, 1)
+    if (this[TYPE] === '')
+      this[TYPE] = '0'
+    if (this[TYPE] === '0' && this.path.substr(-1) === '/')
+      this[TYPE] = '5'
+
+    // tar implementations sometimes incorrectly put the stat(dir).size
+    // as the size in the tarball, even though Directory entries are
+    // not able to have any body at all.  In the very rare chance that
+    // it actually DOES have a body, we weren't going to do anything with
+    // it anyway, and it'll just be a warning about an invalid header.
+    if (this[TYPE] === '5')
+      this.size = 0
+
+    this.linkpath = decString(buf, off + 157, 100)
+    if (buf.slice(off + 257, off + 265).toString() === 'ustar\u000000') {
+      this.uname = decString(buf, off + 265, 32)
+      this.gname = decString(buf, off + 297, 32)
+      this.devmaj = decNumber(buf, off + 329, 8)
+      this.devmin = decNumber(buf, off + 337, 8)
+      if (buf[off + 475] !== 0) {
+        // definitely a prefix, definitely >130 chars.
+        const prefix = decString(buf, off + 345, 155)
+        this.path = prefix + '/' + this.path
+      } else {
+        const prefix = decString(buf, off + 345, 130)
+        if (prefix)
+          this.path = prefix + '/' + this.path
+        this.atime = decDate(buf, off + 476, 12)
+        this.ctime = decDate(buf, off + 488, 12)
+      }
+    }
 
-  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
+    let sum = 8 * 0x20
+    for (let i = off; i < off + 148; i++) {
+      sum += buf[i]
+    }
+    for (let i = off + 156; i < off + 512; i++) {
+      sum += buf[i]
     }
-    obj.needExtended = obj.needExtended || ret
+    this.cksumValid = sum === this.cksum
+    if (this.cksum === null && sum === 8 * 0x20)
+      this.nullBlock = true
   }
 
-  var off = fieldOffs[fields.cksum]
-    , end = fieldEnds[fields.cksum]
-
-  writeNumeric(block, off, end, calcSum.call(this, block))
+  encode (buf, off) {
+    if (!buf) {
+      buf = this.block = Buffer.alloc(512)
+      off = 0
+    }
 
-  return block
-}
+    if (!off)
+      off = 0
+
+    if (!(buf.length >= off + 512))
+      throw new Error('need 512 bytes for header')
+
+    const prefixSize = this.ctime || this.atime ? 130 : 155
+    const split = splitPrefix(this.path || '', prefixSize)
+    const path = split[0]
+    const prefix = split[1]
+    this.needPax = split[2]
+
+    this.needPax = encString(buf, off, 100, path) || this.needPax
+    this.needPax = encNumber(buf, off + 100, 8, this.mode) || this.needPax
+    this.needPax = encNumber(buf, off + 108, 8, this.uid) || this.needPax
+    this.needPax = encNumber(buf, off + 116, 8, this.gid) || this.needPax
+    this.needPax = encNumber(buf, off + 124, 12, this.size) || this.needPax
+    this.needPax = encDate(buf, off + 136, 12, this.mtime) || this.needPax
+    buf[off + 156] = this[TYPE].charCodeAt(0)
+    this.needPax = encString(buf, off + 157, 100, this.linkpath) || this.needPax
+    buf.write('ustar\u000000', off + 257, 8)
+    this.needPax = encString(buf, off + 265, 32, this.uname) || this.needPax
+    this.needPax = encString(buf, off + 297, 32, this.gname) || this.needPax
+    this.needPax = encNumber(buf, off + 329, 8, this.devmaj) || this.needPax
+    this.needPax = encNumber(buf, off + 337, 8, this.devmin) || this.needPax
+    this.needPax = encString(buf, off + 345, prefixSize, prefix) || this.needPax
+    if (buf[off + 475] !== 0)
+      this.needPax = encString(buf, off + 345, 155, prefix) || this.needPax
+    else {
+      this.needPax = encString(buf, off + 345, 130, prefix) || this.needPax
+      this.needPax = encDate(buf, off + 476, 12, this.atime) || this.needPax
+      this.needPax = encDate(buf, off + 488, 12, this.ctime) || this.needPax
+    }
 
-// 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
-  }
+    let sum = 8 * 0x20
+    for (let i = off; i < off + 148; i++) {
+      sum += buf[i]
+    }
+    for (let i = off + 156; i < off + 512; i++) {
+      sum += buf[i]
+    }
+    this.cksum = sum
+    encNumber(buf, off + 148, 8, this.cksum)
+    this.cksumValid = true
 
-  if (num > maxNum || num < 0) {
-    write256(block, off, end, num)
-    // need an extended header if negative or too big.
-    return true
+    return this.needPax
   }
 
-  // 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
+  set (data) {
+    for (let i in data) {
+      if (data[i] !== null && data[i] !== undefined)
+        this[i] = data[i]
+    }
   }
 
-  if (numStr.length !== writeLen - 1) {
-    throw new Error("invalid length: " + JSON.stringify(numStr) + "\n" +
-                    "expected: "+writeLen)
+  get type () {
+    return types.name.get(this[TYPE]) || this[TYPE]
   }
-  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
+  get typeKey () {
+    return this[TYPE]
   }
 
-  // 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
+  set type (type) {
+    if (types.code.has(type))
+      this[TYPE] = types.code.get(type)
+    else
+      this[TYPE] = type
   }
 }
 
-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]
+const splitPrefix = (p, prefixSize) => {
+  const pathSize = 100
+  let pp = p
+  let prefix = ''
+  let ret
+  const root = pathModule.parse(p).root || '.'
+
+  if (Buffer.byteLength(pp) < pathSize)
+    ret = [pp, prefix, false]
+  else {
+    // first set prefix to the dir, and path to the base
+    prefix = pathModule.dirname(pp)
+    pp = pathModule.basename(pp)
+
+    do {
+      // both fit!
+      if (Buffer.byteLength(pp) <= pathSize &&
+          Buffer.byteLength(prefix) <= prefixSize)
+        ret = [pp, prefix, false]
+
+      // prefix fits in prefix, but path doesn't fit in path
+      else if (Buffer.byteLength(pp) > pathSize &&
+          Buffer.byteLength(prefix) <= prefixSize)
+        ret = [pp.substr(0, pathSize - 1), prefix, true]
+
+      else {
+        // make path take a bit from prefix
+        pp = pathModule.join(pathModule.basename(prefix), pp)
+        prefix = pathModule.dirname(prefix)
+      }
+    } while (prefix !== root && !ret)
+
+    // at this point, found no resolution, just truncate
+    if (!ret)
+      ret = [p.substr(0, pathSize - 1), '', true]
   }
-
-  for (var i = start; i < end; i ++) {
-    sum += space
-  }
-
-  for (var i = end; i < 512; i ++) {
-    sum += block[i]
-  }
-
-  return sum
+  return ret
 }
 
+const decString = (buf, off, size) =>
+  buf.slice(off, off + size).toString('utf8').replace(/\0.*/, '')
 
-function checkSum (block) {
-  var sum = calcSum.call(this, block)
-  block = block || this.block
+const decDate = (buf, off, size) =>
+  numToDate(decNumber(buf, off, size))
 
-  var cksum = block.slice(fieldOffs[fields.cksum], fieldEnds[fields.cksum])
-  cksum = parseNumeric(cksum)
+const numToDate = num => num === null ? null : new Date(num * 1000)
 
-  return cksum === sum
-}
+const decNumber = (buf, off, size) =>
+  buf[off] & 0x80 ? large.parse(buf.slice(off, off + size))
+    : decSmallNumber(buf, off, size)
 
-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
-    }
-  }
+const nanNull = value => isNaN(value) ? null : value
 
-  // 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)
-  }
+const decSmallNumber = (buf, off, size) =>
+  nanNull(parseInt(
+    buf.slice(off, off + size)
+      .toString('utf8').replace(/\0.*$/, '').trim(), 8))
+
+// the maximum encodable as a null-terminated octal, by field size
+const MAXNUM = {
+  12: 0o77777777777,
+  8 : 0o7777777
 }
 
-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)
-  }
+const encNumber = (buf, off, size, number) =>
+  number === null ? false :
+  number > MAXNUM[size] || number < 0
+    ? (large.encode(number, buf.slice(off, off + size)), true)
+    : (encSmallNumber(buf, off, size, number), false)
 
-  for (var sum = 0, i = 0, l = tuple.length; i < l; i ++) {
-    sum += tuple[i] * Math.pow(256, i)
-  }
+const encSmallNumber = (buf, off, size, number) =>
+  buf.write(octalString(number, size), off, size, 'ascii')
 
-  return positive ? sum : -1 * sum
-}
+const octalString = (number, size) =>
+  padOctal(Math.floor(number).toString(8), size)
 
-function parseNumeric (f) {
-  if (f[0] & 0x80) return parse256(f)
+const padOctal = (string, size) =>
+  (string.length === size - 1 ? string
+  : new Array(size - string.length - 1).join('0') + string + ' ') + '\0'
 
-  var str = f.toString("utf8").split("\0")[0].trim()
-    , res = parseInt(str, 8)
+const encDate = (buf, off, size, date) =>
+  date === null ? false :
+  encNumber(buf, off, size, date.getTime() / 1000)
 
-  return isNaN(res) ? null : res
-}
+// enough to fill the longest string we've got
+const NULLS = new Array(156).join('\0')
+// pad with nulls, return true if it's longer or non-ascii
+const encString = (buf, off, size, string) =>
+  string === null ? false :
+  (buf.write(string + NULLS, off, size, 'utf8'),
+   string.length !== Buffer.byteLength(string) || string.length > size)
 
+module.exports = Header

package/node_modules/tar/lib/high-level-opt.js

@@ -0,0 +1,29 @@
+'use strict'
+
+// turn tar(1) style args like `C` into the more verbose things like `cwd`
+
+const argmap = new Map([
+  ['C', 'cwd'],
+  ['f', 'file'],
+  ['z', 'gzip'],
+  ['P', 'preservePaths'],
+  ['U', 'unlink'],
+  ['strip-components', 'strip'],
+  ['stripComponents', 'strip'],
+  ['keep-newer', 'newer'],
+  ['keepNewer', 'newer'],
+  ['keep-newer-files', 'newer'],
+  ['keepNewerFiles', 'newer'],
+  ['k', 'keep'],
+  ['keep-existing', 'keep'],
+  ['keepExisting', 'keep'],
+  ['m', 'noMtime'],
+  ['no-mtime', 'noMtime'],
+  ['p', 'preserveOwner'],
+  ['L', 'follow'],
+  ['h', 'follow']
+])
+
+const parse = module.exports = opt => opt ? Object.keys(opt).map(k => [
+  argmap.has(k) ? argmap.get(k) : k, opt[k]
+]).reduce((set, kv) => (set[kv[0]] = kv[1], set), Object.create(null)) : {}