muhammara 3.2.0 → 3.3.0

package/node_modules/tar/lib/parse.js

@@ -28,6 +28,7 @@ const maxMetaEntrySize = 1024 * 1024
 const Entry = require('./read-entry.js')
 const Pax = require('./pax.js')
 const zlib = require('minizlib')
+const { nextTick } = require('process')
 
 const gzipHeader = Buffer.from([0x1f, 0x8b])
 const STATE = Symbol('state')
@@ -59,6 +60,7 @@ const DONE = Symbol('onDone')
 const SAW_VALID_ENTRY = Symbol('sawValidEntry')
 const SAW_NULL_BLOCK = Symbol('sawNullBlock')
 const SAW_EOF = Symbol('sawEOF')
+const CLOSESTREAM = Symbol('closeStream')
 
 const noop = _ => true
 
@@ -82,14 +84,13 @@ module.exports = warner(class Parser extends EE {
       }
     })
 
-    if (opt.ondone)
+    if (opt.ondone) {
       this.on(DONE, opt.ondone)
-    else {
+    } else {
       this.on(DONE, _ => {
         this.emit('prefinish')
         this.emit('finish')
         this.emit('end')
-        this.emit('close')
       })
     }
 
@@ -114,15 +115,21 @@ module.exports = warner(class Parser extends EE {
     this[ABORTED] = false
     this[SAW_NULL_BLOCK] = false
     this[SAW_EOF] = false
-    if (typeof opt.onwarn === 'function')
+
+    this.on('end', () => this[CLOSESTREAM]())
+
+    if (typeof opt.onwarn === 'function') {
       this.on('warn', opt.onwarn)
-    if (typeof opt.onentry === 'function')
+    }
+    if (typeof opt.onentry === 'function') {
       this.on('entry', opt.onentry)
+    }
   }
 
   [CONSUMEHEADER] (chunk, position) {
-    if (this[SAW_VALID_ENTRY] === null)
+    if (this[SAW_VALID_ENTRY] === null) {
       this[SAW_VALID_ENTRY] = false
+    }
     let header
     try {
       header = new Header(chunk, position, this[EX], this[GEX])
@@ -134,8 +141,9 @@ module.exports = warner(class Parser extends EE {
       if (this[SAW_NULL_BLOCK]) {
         this[SAW_EOF] = true
         // ending an archive with no entries.  pointless, but legal.
-        if (this[STATE] === 'begin')
+        if (this[STATE] === 'begin') {
           this[STATE] = 'header'
+        }
         this[EMIT]('eof')
       } else {
         this[SAW_NULL_BLOCK] = true
@@ -143,17 +151,17 @@ module.exports = warner(class Parser extends EE {
       }
     } else {
       this[SAW_NULL_BLOCK] = false
-      if (!header.cksumValid)
-        this.warn('TAR_ENTRY_INVALID', 'checksum failure', {header})
-      else if (!header.path)
-        this.warn('TAR_ENTRY_INVALID', 'path is required', {header})
-      else {
+      if (!header.cksumValid) {
+        this.warn('TAR_ENTRY_INVALID', 'checksum failure', { header })
+      } else if (!header.path) {
+        this.warn('TAR_ENTRY_INVALID', 'path is required', { header })
+      } else {
         const type = header.type
-        if (/^(Symbolic)?Link$/.test(type) && !header.linkpath)
-          this.warn('TAR_ENTRY_INVALID', 'linkpath required', {header})
-        else if (!/^(Symbolic)?Link$/.test(type) && header.linkpath)
-          this.warn('TAR_ENTRY_INVALID', 'linkpath forbidden', {header})
-        else {
+        if (/^(Symbolic)?Link$/.test(type) && !header.linkpath) {
+          this.warn('TAR_ENTRY_INVALID', 'linkpath required', { header })
+        } else if (!/^(Symbolic)?Link$/.test(type) && header.linkpath) {
+          this.warn('TAR_ENTRY_INVALID', 'linkpath forbidden', { header })
+        } else {
           const entry = this[WRITEENTRY] = new Entry(header, this[EX], this[GEX])
 
           // we do this for meta & ignored entries as well, because they
@@ -162,12 +170,14 @@ module.exports = warner(class Parser extends EE {
             if (entry.remain) {
               // this might be the one!
               const onend = () => {
-                if (!entry.invalid)
+                if (!entry.invalid) {
                   this[SAW_VALID_ENTRY] = true
+                }
               }
               entry.on('end', onend)
-            } else
+            } else {
               this[SAW_VALID_ENTRY] = true
+            }
           }
 
           if (entry.meta) {
@@ -191,9 +201,9 @@ module.exports = warner(class Parser extends EE {
               this[STATE] = entry.remain ? 'ignore' : 'header'
               entry.resume()
             } else {
-              if (entry.remain)
+              if (entry.remain) {
                 this[STATE] = 'body'
-              else {
+              } else {
                 this[STATE] = 'header'
                 entry.end()
               }
@@ -201,8 +211,9 @@ module.exports = warner(class Parser extends EE {
               if (!this[READENTRY]) {
                 this[QUEUE].push(entry)
                 this[NEXTENTRY]()
-              } else
+              } else {
                 this[QUEUE].push(entry)
+              }
             }
           }
         }
@@ -210,15 +221,19 @@ module.exports = warner(class Parser extends EE {
     }
   }
 
+  [CLOSESTREAM] () {
+    nextTick(() => this.emit('close'))
+  }
+
   [PROCESSENTRY] (entry) {
     let go = true
 
     if (!entry) {
       this[READENTRY] = null
       go = false
-    } else if (Array.isArray(entry))
+    } else if (Array.isArray(entry)) {
       this.emit.apply(this, entry)
-    else {
+    } else {
       this[READENTRY] = entry
       this.emit('entry', entry)
       if (!entry.emittedEnd) {
@@ -244,10 +259,12 @@ module.exports = warner(class Parser extends EE {
       const re = this[READENTRY]
       const drainNow = !re || re.flowing || re.size === re.remain
       if (drainNow) {
-        if (!this[WRITING])
+        if (!this[WRITING]) {
           this.emit('drain')
-      } else
+        }
+      } else {
         re.once('drain', _ => this.emit('drain'))
+      }
     }
   }
 
@@ -274,17 +291,19 @@ module.exports = warner(class Parser extends EE {
     const ret = this[CONSUMEBODY](chunk, position)
 
     // if we finished, then the entry is reset
-    if (!this[WRITEENTRY])
+    if (!this[WRITEENTRY]) {
       this[EMITMETA](entry)
+    }
 
     return ret
   }
 
   [EMIT] (ev, data, extra) {
-    if (!this[QUEUE].length && !this[READENTRY])
+    if (!this[QUEUE].length && !this[READENTRY]) {
       this.emit(ev, data, extra)
-    else
+    } else {
       this[QUEUE].push([ev, data, extra])
+    }
   }
 
   [EMITMETA] (entry) {
@@ -323,8 +342,9 @@ module.exports = warner(class Parser extends EE {
   }
 
   write (chunk) {
-    if (this[ABORTED])
+    if (this[ABORTED]) {
       return
+    }
 
     // first write, might be gzipped
     if (this[UNZIP] === null && chunk) {
@@ -337,8 +357,9 @@ module.exports = warner(class Parser extends EE {
         return true
       }
       for (let i = 0; this[UNZIP] === null && i < gzipHeader.length; i++) {
-        if (chunk[i] !== gzipHeader[i])
+        if (chunk[i] !== gzipHeader[i]) {
           this[UNZIP] = false
+        }
       }
       if (this[UNZIP] === null) {
         const ended = this[ENDED]
@@ -358,10 +379,11 @@ module.exports = warner(class Parser extends EE {
     }
 
     this[WRITING] = true
-    if (this[UNZIP])
+    if (this[UNZIP]) {
       this[UNZIP].write(chunk)
-    else
+    } else {
       this[CONSUMECHUNK](chunk)
+    }
     this[WRITING] = false
 
     // return false if there's a queue, or if the current entry isn't flowing
@@ -371,15 +393,17 @@ module.exports = warner(class Parser extends EE {
       true
 
     // if we have no queue, then that means a clogged READENTRY
-    if (!ret && !this[QUEUE].length)
+    if (!ret && !this[QUEUE].length) {
       this[READENTRY].once('drain', _ => this.emit('drain'))
+    }
 
     return ret
   }
 
   [BUFFERCONCAT] (c) {
-    if (c && !this[ABORTED])
+    if (c && !this[ABORTED]) {
       this[BUFFER] = this[BUFFER] ? Buffer.concat([this[BUFFER], c]) : c
+    }
   }
 
   [MAYBEEND] () {
@@ -393,9 +417,10 @@ module.exports = warner(class Parser extends EE {
         // truncated, likely a damaged file
         const have = this[BUFFER] ? this[BUFFER].length : 0
         this.warn('TAR_BAD_ARCHIVE', `Truncated input (needed ${
-          entry.blockRemain} more bytes, only ${have} available)`, {entry})
-        if (this[BUFFER])
+          entry.blockRemain} more bytes, only ${have} available)`, { entry })
+        if (this[BUFFER]) {
           entry.write(this[BUFFER])
+        }
         entry.end()
       }
       this[EMIT](DONE)
@@ -403,19 +428,20 @@ module.exports = warner(class Parser extends EE {
   }
 
   [CONSUMECHUNK] (chunk) {
-    if (this[CONSUMING])
+    if (this[CONSUMING]) {
       this[BUFFERCONCAT](chunk)
-    else if (!chunk && !this[BUFFER])
+    } else if (!chunk && !this[BUFFER]) {
       this[MAYBEEND]()
-    else {
+    } else {
       this[CONSUMING] = true
       if (this[BUFFER]) {
         this[BUFFERCONCAT](chunk)
         const c = this[BUFFER]
         this[BUFFER] = null
         this[CONSUMECHUNKSUB](c)
-      } else
+      } else {
         this[CONSUMECHUNKSUB](chunk)
+      }
 
       while (this[BUFFER] &&
           this[BUFFER].length >= 512 &&
@@ -428,8 +454,9 @@ module.exports = warner(class Parser extends EE {
       this[CONSUMING] = false
     }
 
-    if (!this[BUFFER] || this[ENDED])
+    if (!this[BUFFER] || this[ENDED]) {
       this[MAYBEEND]()
+    }
   }
 
   [CONSUMECHUNKSUB] (chunk) {
@@ -461,18 +488,19 @@ module.exports = warner(class Parser extends EE {
     }
 
     if (position < length) {
-      if (this[BUFFER])
+      if (this[BUFFER]) {
         this[BUFFER] = Buffer.concat([chunk.slice(position), this[BUFFER]])
-      else
+      } else {
         this[BUFFER] = chunk.slice(position)
+      }
     }
   }
 
   end (chunk) {
     if (!this[ABORTED]) {
-      if (this[UNZIP])
+      if (this[UNZIP]) {
         this[UNZIP].end(chunk)
-      else {
+      } else {
         this[ENDED] = true
         this.write(chunk)
       }

package/node_modules/tar/lib/path-reservations.js

@@ -27,8 +27,9 @@ module.exports = () => {
   // '/a/b/c/d' -> ['/', '/a', '/a/b', '/a/b/c', '/a/b/c/d']
   const getDirs = path => {
     const dirs = path.split('/').slice(0, -1).reduce((set, path) => {
-      if (set.length)
+      if (set.length) {
         path = join(set[set.length - 1], path)
+      }
       set.push(path || '/')
       return set
     }, [])
@@ -43,8 +44,9 @@ module.exports = () => {
   const getQueues = fn => {
     const res = reservations.get(fn)
     /* istanbul ignore if - unpossible */
-    if (!res)
+    if (!res) {
       throw new Error('function does not have any path reservations')
+    }
     return {
       paths: res.paths.map(path => queues.get(path)),
       dirs: [...res.dirs].map(path => queues.get(path)),
@@ -54,23 +56,25 @@ module.exports = () => {
   // check if fn is first in line for all its paths, and is
   // included in the first set for all its dir queues
   const check = fn => {
-    const {paths, dirs} = getQueues(fn)
+    const { paths, dirs } = getQueues(fn)
     return paths.every(q => q[0] === fn) &&
       dirs.every(q => q[0] instanceof Set && q[0].has(fn))
   }
 
   // run the function if it's first in line and not already running
   const run = fn => {
-    if (running.has(fn) || !check(fn))
+    if (running.has(fn) || !check(fn)) {
       return false
+    }
     running.add(fn)
     fn(() => clear(fn))
     return true
   }
 
   const clear = fn => {
-    if (!running.has(fn))
+    if (!running.has(fn)) {
       return false
+    }
 
     const { paths, dirs } = reservations.get(fn)
     const next = new Set()
@@ -78,29 +82,31 @@ module.exports = () => {
     paths.forEach(path => {
       const q = queues.get(path)
       assert.equal(q[0], fn)
-      if (q.length === 1)
+      if (q.length === 1) {
         queues.delete(path)
-      else {
+      } else {
         q.shift()
-        if (typeof q[0] === 'function')
+        if (typeof q[0] === 'function') {
           next.add(q[0])
-        else
+        } else {
           q[0].forEach(fn => next.add(fn))
+        }
       }
     })
 
     dirs.forEach(dir => {
       const q = queues.get(dir)
       assert(q[0] instanceof Set)
-      if (q[0].size === 1 && q.length === 1)
+      if (q[0].size === 1 && q.length === 1) {
         queues.delete(dir)
-      else if (q[0].size === 1) {
+      } else if (q[0].size === 1) {
         q.shift()
 
         // must be a function or else the Set would've been reused
         next.add(q[0])
-      } else
+      } else {
         q[0].delete(fn)
+      }
     })
     running.delete(fn)
 
@@ -123,22 +129,24 @@ module.exports = () => {
     const dirs = new Set(
       paths.map(path => getDirs(path)).reduce((a, b) => a.concat(b))
     )
-    reservations.set(fn, {dirs, paths})
+    reservations.set(fn, { dirs, paths })
     paths.forEach(path => {
       const q = queues.get(path)
-      if (!q)
+      if (!q) {
         queues.set(path, [fn])
-      else
+      } else {
         q.push(fn)
+      }
     })
     dirs.forEach(dir => {
       const q = queues.get(dir)
-      if (!q)
+      if (!q) {
         queues.set(dir, [new Set([fn])])
-      else if (q[q.length - 1] instanceof Set)
+      } else if (q[q.length - 1] instanceof Set) {
         q[q.length - 1].add(fn)
-      else
+      } else {
         q.push(new Set([fn]))
+      }
     })
 
     return run(fn)

package/node_modules/tar/lib/pax.js

@@ -24,8 +24,9 @@ class Pax {
 
   encode () {
     const body = this.encodeBody()
-    if (body === '')
+    if (body === '') {
       return null
+    }
 
     const bodyLen = Buffer.byteLength(body)
     // round up to 512 bytes
@@ -34,8 +35,9 @@ class Pax {
     const buf = Buffer.allocUnsafe(bufLen)
 
     // 0-fill the header section, it might not hit every field
-    for (let i = 0; i < 512; i++)
+    for (let i = 0; i < 512; i++) {
       buf[i] = 0
+    }
 
     new Header({
       // XXX split the path
@@ -60,8 +62,9 @@ class Pax {
     buf.write(body, 512, bodyLen, 'utf8')
 
     // null pad after the body
-    for (let i = bodyLen + 512; i < buf.length; i++)
+    for (let i = bodyLen + 512; i < buf.length; i++) {
       buf[i] = 0
+    }
 
     return buf
   }
@@ -87,8 +90,9 @@ class Pax {
   }
 
   encodeField (field) {
-    if (this[field] === null || this[field] === undefined)
+    if (this[field] === null || this[field] === undefined) {
       return ''
+    }
     const v = this[field] instanceof Date ? this[field].getTime() / 1000
       : this[field]
     const s = ' ' +
@@ -100,8 +104,9 @@ class Pax {
     // so if it's 9 characters, then adding 1 for the 9 makes it 10
     // which makes it 11 chars.
     let digits = Math.floor(Math.log(byteLen) / Math.log(10)) + 1
-    if (byteLen + digits >= Math.pow(10, digits))
+    if (byteLen + digits >= Math.pow(10, digits)) {
       digits += 1
+    }
     const len = digits + byteLen
     return len + s
   }
@@ -123,14 +128,16 @@ const parseKVLine = (set, line) => {
 
   // XXX Values with \n in them will fail this.
   // Refactor to not be a naive line-by-line parse.
-  if (n !== Buffer.byteLength(line) + 1)
+  if (n !== Buffer.byteLength(line) + 1) {
     return set
+  }
 
-  line = line.substr((n + ' ').length)
+  line = line.slice((n + ' ').length)
   const kv = line.split('=')
   const k = kv.shift().replace(/^SCHILY\.(dev|ino|nlink)/, '$1')
-  if (!k)
+  if (!k) {
     return set
+  }
 
   const v = kv.join('=')
   set[k] = /^([A-Z]+\.)?([mac]|birth|creation)time$/.test(k)

package/node_modules/tar/lib/read-entry.js

@@ -49,8 +49,9 @@ module.exports = class ReadEntry extends MiniPass {
 
     this.path = normPath(header.path)
     this.mode = header.mode
-    if (this.mode)
+    if (this.mode) {
       this.mode = this.mode & 0o7777
+    }
     this.uid = header.uid
     this.gid = header.gid
     this.uname = header.uname
@@ -63,26 +64,31 @@ module.exports = class ReadEntry extends MiniPass {
     this.uname = header.uname
     this.gname = header.gname
 
-    if (ex)
+    if (ex) {
       this[SLURP](ex)
-    if (gex)
+    }
+    if (gex) {
       this[SLURP](gex, true)
+    }
   }
 
   write (data) {
     const writeLen = data.length
-    if (writeLen > this.blockRemain)
+    if (writeLen > this.blockRemain) {
       throw new Error('writing more to entry than is appropriate')
+    }
 
     const r = this.remain
     const br = this.blockRemain
     this.remain = Math.max(0, r - writeLen)
     this.blockRemain = Math.max(0, br - writeLen)
-    if (this.ignore)
+    if (this.ignore) {
       return true
+    }
 
-    if (r >= writeLen)
+    if (r >= writeLen) {
       return super.write(data)
+    }
 
     // r < writeLen
     return super.write(data.slice(0, r))
@@ -93,8 +99,9 @@ module.exports = class ReadEntry extends MiniPass {
       // we slurp in everything except for the path attribute in
       // a global extended header, because that's weird.
       if (ex[k] !== null && ex[k] !== undefined &&
-          !(global && k === 'path'))
+          !(global && k === 'path')) {
         this[k] = k === 'path' || k === 'linkpath' ? normPath(ex[k]) : ex[k]
+      }
     }
   }
 }