cline 1.0.1 → 1.0.2

package/node_modules/tar-stream/extract.js

@@ -1,257 +1,406 @@
-var util = require('util')
-var bl = require('bl')
-var headers = require('./headers')
+const { Writable, Readable, getStreamError } = require('streamx')
+const FIFO = require('fast-fifo')
+const b4a = require('b4a')
+const headers = require('./headers')
 
-var Writable = require('readable-stream').Writable
-var PassThrough = require('readable-stream').PassThrough
+const EMPTY = b4a.alloc(0)
 
-var noop = function () {}
+class BufferList {
+  constructor () {
+    this.buffered = 0
+    this.shifted = 0
+    this.queue = new FIFO()
 
-var overflow = function (size) {
-  size &= 511
-  return size && 512 - size
-}
+    this._offset = 0
+  }
 
-var emptyStream = function (self, offset) {
-  var s = new Source(self, offset)
-  s.end()
-  return s
-}
+  push (buffer) {
+    this.buffered += buffer.byteLength
+    this.queue.push(buffer)
+  }
 
-var mixinPax = function (header, pax) {
-  if (pax.path) header.name = pax.path
-  if (pax.linkpath) header.linkname = pax.linkpath
-  if (pax.size) header.size = parseInt(pax.size, 10)
-  header.pax = pax
-  return header
-}
+  shiftFirst (size) {
+    return this._buffered === 0 ? null : this._next(size)
+  }
 
-var Source = function (self, offset) {
-  this._parent = self
-  this.offset = offset
-  PassThrough.call(this, { autoDestroy: false })
-}
+  shift (size) {
+    if (size > this.buffered) return null
+    if (size === 0) return EMPTY
 
-util.inherits(Source, PassThrough)
+    let chunk = this._next(size)
 
-Source.prototype.destroy = function (err) {
-  this._parent.destroy(err)
-}
+    if (size === chunk.byteLength) return chunk // likely case
+
+    const chunks = [chunk]
 
-var Extract = function (opts) {
-  if (!(this instanceof Extract)) return new Extract(opts)
-  Writable.call(this, opts)
-
-  opts = opts || {}
-
-  this._offset = 0
-  this._buffer = bl()
-  this._missing = 0
-  this._partial = false
-  this._onparse = noop
-  this._header = null
-  this._stream = null
-  this._overflow = null
-  this._cb = null
-  this._locked = false
-  this._destroyed = false
-  this._pax = null
-  this._paxGlobal = null
-  this._gnuLongPath = null
-  this._gnuLongLinkPath = null
-
-  var self = this
-  var b = self._buffer
-
-  var oncontinue = function () {
-    self._continue()
+    while ((size -= chunk.byteLength) > 0) {
+      chunk = this._next(size)
+      chunks.push(chunk)
+    }
+
+    return b4a.concat(chunks)
   }
 
-  var onunlock = function (err) {
-    self._locked = false
-    if (err) return self.destroy(err)
-    if (!self._stream) oncontinue()
+  _next (size) {
+    const buf = this.queue.peek()
+    const rem = buf.byteLength - this._offset
+
+    if (size >= rem) {
+      const sub = this._offset ? buf.subarray(this._offset, buf.byteLength) : buf
+      this.queue.shift()
+      this._offset = 0
+      this.buffered -= rem
+      this.shifted += rem
+      return sub
+    }
+
+    this.buffered -= size
+    this.shifted += size
+
+    return buf.subarray(this._offset, (this._offset += size))
   }
+}
+
+class Source extends Readable {
+  constructor (self, header, offset) {
+    super()
+
+    this.header = header
+    this.offset = offset
 
-  var onstreamend = function () {
-    self._stream = null
-    var drain = overflow(self._header.size)
-    if (drain) self._parse(drain, ondrain)
-    else self._parse(512, onheader)
-    if (!self._locked) oncontinue()
+    this._parent = self
   }
 
-  var ondrain = function () {
-    self._buffer.consume(overflow(self._header.size))
-    self._parse(512, onheader)
-    oncontinue()
+  _read (cb) {
+    if (this.header.size === 0) {
+      this.push(null)
+    }
+    if (this._parent._stream === this) {
+      this._parent._update()
+    }
+    cb(null)
   }
 
-  var onpaxglobalheader = function () {
-    var size = self._header.size
-    self._paxGlobal = headers.decodePax(b.slice(0, size))
-    b.consume(size)
-    onstreamend()
+  _predestroy () {
+    this._parent.destroy(getStreamError(this))
   }
 
-  var onpaxheader = function () {
-    var size = self._header.size
-    self._pax = headers.decodePax(b.slice(0, size))
-    if (self._paxGlobal) self._pax = Object.assign({}, self._paxGlobal, self._pax)
-    b.consume(size)
-    onstreamend()
+  _detach () {
+    if (this._parent._stream === this) {
+      this._parent._stream = null
+      this._parent._missing = overflow(this.header.size)
+      this._parent._update()
+    }
   }
 
-  var ongnulongpath = function () {
-    var size = self._header.size
-    this._gnuLongPath = headers.decodeLongPath(b.slice(0, size), opts.filenameEncoding)
-    b.consume(size)
-    onstreamend()
+  _destroy (cb) {
+    this._detach()
+    cb(null)
   }
+}
+
+class Extract extends Writable {
+  constructor (opts) {
+    super(opts)
+
+    if (!opts) opts = {}
+
+    this._buffer = new BufferList()
+    this._offset = 0
+    this._header = null
+    this._stream = null
+    this._missing = 0
+    this._longHeader = false
+    this._callback = noop
+    this._locked = false
+    this._finished = false
+    this._pax = null
+    this._paxGlobal = null
+    this._gnuLongPath = null
+    this._gnuLongLinkPath = null
+    this._filenameEncoding = opts.filenameEncoding || 'utf-8'
+    this._allowUnknownFormat = !!opts.allowUnknownFormat
+    this._unlockBound = this._unlock.bind(this)
+  }
+
+  _unlock (err) {
+    this._locked = false
 
-  var ongnulonglinkpath = function () {
-    var size = self._header.size
-    this._gnuLongLinkPath = headers.decodeLongPath(b.slice(0, size), opts.filenameEncoding)
-    b.consume(size)
-    onstreamend()
+    if (err) {
+      this.destroy(err)
+      this._continueWrite(err)
+      return
+    }
+
+    this._update()
   }
 
-  var onheader = function () {
-    var offset = self._offset
-    var header
+  _consumeHeader () {
+    if (this._locked) return false
+
+    this._offset = this._buffer.shifted
+
     try {
-      header = self._header = headers.decode(b.slice(0, 512), opts.filenameEncoding, opts.allowUnknownFormat)
+      this._header = headers.decode(this._buffer.shift(512), this._filenameEncoding, this._allowUnknownFormat)
     } catch (err) {
-      self.emit('error', err)
+      this._continueWrite(err)
+      return false
     }
-    b.consume(512)
 
-    if (!header) {
-      self._parse(512, onheader)
-      oncontinue()
-      return
+    if (!this._header) return true
+
+    switch (this._header.type) {
+      case 'gnu-long-path':
+      case 'gnu-long-link-path':
+      case 'pax-global-header':
+      case 'pax-header':
+        this._longHeader = true
+        this._missing = this._header.size
+        return true
     }
-    if (header.type === 'gnu-long-path') {
-      self._parse(header.size, ongnulongpath)
-      oncontinue()
-      return
+
+    this._locked = true
+    this._applyLongHeaders()
+
+    if (this._header.size === 0 || this._header.type === 'directory') {
+      this.emit('entry', this._header, this._createStream(), this._unlockBound)
+      return true
     }
-    if (header.type === 'gnu-long-link-path') {
-      self._parse(header.size, ongnulonglinkpath)
-      oncontinue()
-      return
+
+    this._stream = this._createStream()
+    this._missing = this._header.size
+
+    this.emit('entry', this._header, this._stream, this._unlockBound)
+    return true
+  }
+
+  _applyLongHeaders () {
+    if (this._gnuLongPath) {
+      this._header.name = this._gnuLongPath
+      this._gnuLongPath = null
     }
-    if (header.type === 'pax-global-header') {
-      self._parse(header.size, onpaxglobalheader)
-      oncontinue()
-      return
+
+    if (this._gnuLongLinkPath) {
+      this._header.linkname = this._gnuLongLinkPath
+      this._gnuLongLinkPath = null
     }
-    if (header.type === 'pax-header') {
-      self._parse(header.size, onpaxheader)
-      oncontinue()
-      return
+
+    if (this._pax) {
+      if (this._pax.path) this._header.name = this._pax.path
+      if (this._pax.linkpath) this._header.linkname = this._pax.linkpath
+      if (this._pax.size) this._header.size = parseInt(this._pax.size, 10)
+      this._header.pax = this._pax
+      this._pax = null
     }
+  }
 
-    if (self._gnuLongPath) {
-      header.name = self._gnuLongPath
-      self._gnuLongPath = null
+  _decodeLongHeader (buf) {
+    switch (this._header.type) {
+      case 'gnu-long-path':
+        this._gnuLongPath = headers.decodeLongPath(buf, this._filenameEncoding)
+        break
+      case 'gnu-long-link-path':
+        this._gnuLongLinkPath = headers.decodeLongPath(buf, this._filenameEncoding)
+        break
+      case 'pax-global-header':
+        this._paxGlobal = headers.decodePax(buf)
+        break
+      case 'pax-header':
+        this._pax = this._paxGlobal === null
+          ? headers.decodePax(buf)
+          : Object.assign({}, this._paxGlobal, headers.decodePax(buf))
+        break
     }
+  }
+
+  _consumeLongHeader () {
+    this._longHeader = false
+    this._missing = overflow(this._header.size)
+
+    const buf = this._buffer.shift(this._header.size)
 
-    if (self._gnuLongLinkPath) {
-      header.linkname = self._gnuLongLinkPath
-      self._gnuLongLinkPath = null
+    try {
+      this._decodeLongHeader(buf)
+    } catch (err) {
+      this._continueWrite(err)
+      return false
     }
 
-    if (self._pax) {
-      self._header = header = mixinPax(header, self._pax)
-      self._pax = null
+    return true
+  }
+
+  _consumeStream () {
+    const buf = this._buffer.shiftFirst(this._missing)
+    if (buf === null) return false
+
+    this._missing -= buf.byteLength
+    const drained = this._stream.push(buf)
+
+    if (this._missing === 0) {
+      this._stream.push(null)
+      if (drained) this._stream._detach()
+      return drained && this._locked === false
     }
 
-    self._locked = true
+    return drained
+  }
+
+  _createStream () {
+    return new Source(this, this._header, this._offset)
+  }
 
-    if (!header.size || header.type === 'directory') {
-      self._parse(512, onheader)
-      self.emit('entry', header, emptyStream(self, offset), onunlock)
-      return
+  _update () {
+    while (this._buffer.buffered > 0 && !this.destroying) {
+      if (this._missing > 0) {
+        if (this._stream !== null) {
+          if (this._consumeStream() === false) return
+          continue
+        }
+
+        if (this._longHeader === true) {
+          if (this._missing > this._buffer.buffered) break
+          if (this._consumeLongHeader() === false) return false
+          continue
+        }
+
+        const ignore = this._buffer.shiftFirst(this._missing)
+        if (ignore !== null) this._missing -= ignore.byteLength
+        continue
+      }
+
+      if (this._buffer.buffered < 512) break
+      if (this._stream !== null || this._consumeHeader() === false) return
     }
 
-    self._stream = new Source(self, offset)
+    this._continueWrite(null)
+  }
 
-    self.emit('entry', header, self._stream, onunlock)
-    self._parse(header.size, onstreamend)
-    oncontinue()
+  _continueWrite (err) {
+    const cb = this._callback
+    this._callback = noop
+    cb(err)
   }
 
-  this._onheader = onheader
-  this._parse(512, onheader)
-}
+  _write (data, cb) {
+    this._callback = cb
+    this._buffer.push(data)
+    this._update()
+  }
 
-util.inherits(Extract, Writable)
+  _final (cb) {
+    this._finished = this._missing === 0 && this._buffer.buffered === 0
+    cb(this._finished ? null : new Error('Unexpected end of data'))
+  }
 
-Extract.prototype.destroy = function (err) {
-  if (this._destroyed) return
-  this._destroyed = true
+  _predestroy () {
+    this._continueWrite(null)
+  }
 
-  if (err) this.emit('error', err)
-  this.emit('close')
-  if (this._stream) this._stream.emit('close')
-}
+  _destroy (cb) {
+    if (this._stream) this._stream.destroy(getStreamError(this))
+    cb(null)
+  }
 
-Extract.prototype._parse = function (size, onparse) {
-  if (this._destroyed) return
-  this._offset += size
-  this._missing = size
-  if (onparse === this._onheader) this._partial = false
-  this._onparse = onparse
-}
+  [Symbol.asyncIterator] () {
+    let error = null
+
+    let promiseResolve = null
+    let promiseReject = null
+
+    let entryStream = null
+    let entryCallback = null
+
+    const extract = this
+
+    this.on('entry', onentry)
+    this.on('error', (err) => { error = err })
+    this.on('close', onclose)
+
+    return {
+      [Symbol.asyncIterator] () {
+        return this
+      },
+      next () {
+        return new Promise(onnext)
+      },
+      return () {
+        return destroy(null)
+      },
+      throw (err) {
+        return destroy(err)
+      }
+    }
 
-Extract.prototype._continue = function () {
-  if (this._destroyed) return
-  var cb = this._cb
-  this._cb = noop
-  if (this._overflow) this._write(this._overflow, undefined, cb)
-  else cb()
-}
+    function consumeCallback (err) {
+      if (!entryCallback) return
+      const cb = entryCallback
+      entryCallback = null
+      cb(err)
+    }
 
-Extract.prototype._write = function (data, enc, cb) {
-  if (this._destroyed) return
+    function onnext (resolve, reject) {
+      if (error) {
+        return reject(error)
+      }
 
-  var s = this._stream
-  var b = this._buffer
-  var missing = this._missing
-  if (data.length) this._partial = true
+      if (entryStream) {
+        resolve({ value: entryStream, done: false })
+        entryStream = null
+        return
+      }
 
-  // we do not reach end-of-chunk now. just forward it
+      promiseResolve = resolve
+      promiseReject = reject
 
-  if (data.length < missing) {
-    this._missing -= data.length
-    this._overflow = null
-    if (s) return s.write(data, cb)
-    b.append(data)
-    return cb()
-  }
+      consumeCallback(null)
 
-  // end-of-chunk. the parser should call cb.
+      if (extract._finished && promiseResolve) {
+        promiseResolve({ value: undefined, done: true })
+        promiseResolve = promiseReject = null
+      }
+    }
 
-  this._cb = cb
-  this._missing = 0
+    function onentry (header, stream, callback) {
+      entryCallback = callback
+      stream.on('error', noop) // no way around this due to tick sillyness
 
-  var overflow = null
-  if (data.length > missing) {
-    overflow = data.slice(missing)
-    data = data.slice(0, missing)
-  }
+      if (promiseResolve) {
+        promiseResolve({ value: stream, done: false })
+        promiseResolve = promiseReject = null
+      } else {
+        entryStream = stream
+      }
+    }
 
-  if (s) s.end(data)
-  else b.append(data)
+    function onclose () {
+      consumeCallback(error)
+      if (!promiseResolve) return
+      if (error) promiseReject(error)
+      else promiseResolve({ value: undefined, done: true })
+      promiseResolve = promiseReject = null
+    }
 
-  this._overflow = overflow
-  this._onparse()
+    function destroy (err) {
+      extract.destroy(err)
+      consumeCallback(err)
+      return new Promise((resolve, reject) => {
+        if (extract.destroyed) return resolve({ value: undefined, done: true })
+        extract.once('close', function () {
+          if (err) reject(err)
+          else resolve({ value: undefined, done: true })
+        })
+      })
+    }
+  }
 }
 
-Extract.prototype._final = function (cb) {
-  if (this._partial) return this.destroy(new Error('Unexpected end of data'))
-  cb()
+module.exports = function extract (opts) {
+  return new Extract(opts)
 }
 
-module.exports = Extract
+function noop () {}
+
+function overflow (size) {
+  size &= 511
+  return size && 512 - size
+}