muhammara 3.2.0 → 3.4.0

package/node_modules/tar/lib/replace.js

@@ -19,14 +19,17 @@ const Header = require('./header.js')
 module.exports = (opt_, files, cb) => {
   const opt = hlo(opt_)
 
-  if (!opt.file)
+  if (!opt.file) {
     throw new TypeError('file is required')
+  }
 
-  if (opt.gzip)
+  if (opt.gzip) {
     throw new TypeError('cannot append to compressed archives')
+  }
 
-  if (!files || !Array.isArray(files) || !files.length)
+  if (!files || !Array.isArray(files) || !files.length) {
     throw new TypeError('no files or directories specified')
+  }
 
   files = Array.from(files)
 
@@ -45,10 +48,11 @@ const replaceSync = (opt, files) => {
     try {
       fd = fs.openSync(opt.file, 'r+')
     } catch (er) {
-      if (er.code === 'ENOENT')
+      if (er.code === 'ENOENT') {
         fd = fs.openSync(opt.file, 'w+')
-      else
+      } else {
         throw er
+      }
     }
 
     const st = fs.fstatSync(fd)
@@ -60,24 +64,29 @@ const replaceSync = (opt, files) => {
           fd, headBuf, bufPos, headBuf.length - bufPos, position + bufPos
         )
 
-        if (position === 0 && headBuf[0] === 0x1f && headBuf[1] === 0x8b)
+        if (position === 0 && headBuf[0] === 0x1f && headBuf[1] === 0x8b) {
           throw new Error('cannot append to compressed archives')
+        }
 
-        if (!bytes)
+        if (!bytes) {
           break POSITION
+        }
       }
 
       const h = new Header(headBuf)
-      if (!h.cksumValid)
+      if (!h.cksumValid) {
         break
+      }
       const entryBlockSize = 512 * Math.ceil(h.size / 512)
-      if (position + entryBlockSize + 512 > st.size)
+      if (position + entryBlockSize + 512 > st.size) {
         break
+      }
       // the 512 for the header we just parsed will be added as well
       // also jump ahead all the blocks for the body
       position += entryBlockSize
-      if (opt.mtimeCache)
+      if (opt.mtimeCache) {
         opt.mtimeCache.set(h.path, h.mtime)
+      }
     }
     threw = false
 
@@ -106,21 +115,24 @@ const replace = (opt, files, cb) => {
 
   const getPos = (fd, size, cb_) => {
     const cb = (er, pos) => {
-      if (er)
+      if (er) {
         fs.close(fd, _ => cb_(er))
-      else
+      } else {
         cb_(null, pos)
+      }
     }
 
     let position = 0
-    if (size === 0)
+    if (size === 0) {
       return cb(null, 0)
+    }
 
     let bufPos = 0
     const headBuf = Buffer.alloc(512)
     const onread = (er, bytes) => {
-      if (er)
+      if (er) {
         return cb(er)
+      }
       bufPos += bytes
       if (bufPos < 512 && bytes) {
         return fs.read(
@@ -129,27 +141,33 @@ const replace = (opt, files, cb) => {
         )
       }
 
-      if (position === 0 && headBuf[0] === 0x1f && headBuf[1] === 0x8b)
+      if (position === 0 && headBuf[0] === 0x1f && headBuf[1] === 0x8b) {
         return cb(new Error('cannot append to compressed archives'))
+      }
 
       // truncated header
-      if (bufPos < 512)
+      if (bufPos < 512) {
         return cb(null, position)
+      }
 
       const h = new Header(headBuf)
-      if (!h.cksumValid)
+      if (!h.cksumValid) {
         return cb(null, position)
+      }
 
       const entryBlockSize = 512 * Math.ceil(h.size / 512)
-      if (position + entryBlockSize + 512 > size)
+      if (position + entryBlockSize + 512 > size) {
         return cb(null, position)
+      }
 
       position += entryBlockSize + 512
-      if (position >= size)
+      if (position >= size) {
         return cb(null, position)
+      }
 
-      if (opt.mtimeCache)
+      if (opt.mtimeCache) {
         opt.mtimeCache.set(h.path, h.mtime)
+      }
       bufPos = 0
       fs.read(fd, headBuf, 0, 512, position, onread)
     }
@@ -165,16 +183,19 @@ const replace = (opt, files, cb) => {
         return fs.open(opt.file, flag, onopen)
       }
 
-      if (er)
+      if (er) {
         return reject(er)
+      }
 
       fs.fstat(fd, (er, st) => {
-        if (er)
+        if (er) {
           return fs.close(fd, () => reject(er))
+        }
 
         getPos(fd, st.size, (er, position) => {
-          if (er)
+          if (er) {
             return reject(er)
+          }
           const stream = new fsm.WriteStream(opt.file, {
             fd: fd,
             start: position,
@@ -196,13 +217,14 @@ const addFilesSync = (p, files) => {
   files.forEach(file => {
     if (file.charAt(0) === '@') {
       t({
-        file: path.resolve(p.cwd, file.substr(1)),
+        file: path.resolve(p.cwd, file.slice(1)),
         sync: true,
         noResume: true,
         onentry: entry => p.add(entry),
       })
-    } else
+    } else {
       p.add(file)
+    }
   })
   p.end()
 }
@@ -212,12 +234,13 @@ const addFilesAsync = (p, files) => {
     const file = files.shift()
     if (file.charAt(0) === '@') {
       return t({
-        file: path.resolve(p.cwd, file.substr(1)),
+        file: path.resolve(p.cwd, file.slice(1)),
         noResume: true,
         onentry: entry => p.add(entry),
       }).then(_ => addFilesAsync(p, files))
-    } else
+    } else {
       p.add(file)
+    }
   }
   p.end()
 }

package/node_modules/tar/lib/strip-absolute-path.js

@@ -16,7 +16,7 @@ module.exports = path => {
     // but strip the //?/C:/ off of //?/C:/path
     const root = path.charAt(0) === '/' && path.slice(0, 4) !== '//?/' ? '/'
       : parsed.root
-    path = path.substr(root.length)
+    path = path.slice(root.length)
     r += root
     parsed = parse(path)
   }

package/node_modules/tar/lib/unpack.js

@@ -66,21 +66,24 @@ const isWindows = platform === 'win32'
 // See: https://github.com/npm/node-tar/issues/183
 /* istanbul ignore next */
 const unlinkFile = (path, cb) => {
-  if (!isWindows)
+  if (!isWindows) {
     return fs.unlink(path, cb)
+  }
 
   const name = path + '.DELETE.' + crypto.randomBytes(16).toString('hex')
   fs.rename(path, name, er => {
-    if (er)
+    if (er) {
       return cb(er)
+    }
     fs.unlink(name, cb)
   })
 }
 
 /* istanbul ignore next */
 const unlinkFileSync = path => {
-  if (!isWindows)
+  if (!isWindows) {
     return fs.unlinkSync(path)
+  }
 
   const name = path + '.DELETE.' + crypto.randomBytes(16).toString('hex')
   fs.renameSync(path, name)
@@ -109,20 +112,23 @@ const pruneCache = (cache, abs) => {
   abs = cacheKeyNormalize(abs)
   for (const path of cache.keys()) {
     const pnorm = cacheKeyNormalize(path)
-    if (pnorm === abs || pnorm.indexOf(abs + '/') === 0)
+    if (pnorm === abs || pnorm.indexOf(abs + '/') === 0) {
       cache.delete(path)
+    }
   }
 }
 
 const dropCache = cache => {
-  for (const key of cache.keys())
+  for (const key of cache.keys()) {
     cache.delete(key)
+  }
 }
 
 class Unpack extends Parser {
   constructor (opt) {
-    if (!opt)
+    if (!opt) {
       opt = {}
+    }
 
     opt.ondone = _ => {
       this[ENDED] = true
@@ -147,8 +153,9 @@ class Unpack extends Parser {
 
     if (typeof opt.uid === 'number' || typeof opt.gid === 'number') {
       // need both or neither
-      if (typeof opt.uid !== 'number' || typeof opt.gid !== 'number')
+      if (typeof opt.uid !== 'number' || typeof opt.gid !== 'number') {
         throw new TypeError('cannot set owner without number uid and gid')
+      }
       if (opt.preserveOwner) {
         throw new TypeError(
           'cannot preserve owner in archive and also set owner explicitly')
@@ -163,10 +170,11 @@ class Unpack extends Parser {
     }
 
     // default true for root
-    if (opt.preserveOwner === undefined && typeof opt.uid !== 'number')
+    if (opt.preserveOwner === undefined && typeof opt.uid !== 'number') {
       this.preserveOwner = process.getuid && process.getuid() === 0
-    else
+    } else {
       this.preserveOwner = !!opt.preserveOwner
+    }
 
     this.processUid = (this.preserveOwner || this.setOwner) && process.getuid ?
       process.getuid() : null
@@ -215,8 +223,9 @@ class Unpack extends Parser {
   // when extracting.  Mark those errors as unrecoverable, because
   // the Unpack contract cannot be met.
   warn (code, msg, data = {}) {
-    if (code === 'TAR_BAD_ARCHIVE' || code === 'TAR_ABORT')
+    if (code === 'TAR_BAD_ARCHIVE' || code === 'TAR_ABORT') {
       data.recoverable = false
+    }
     return super.warn(code, msg, data)
   }
 
@@ -225,23 +234,24 @@ class Unpack extends Parser {
       this.emit('prefinish')
       this.emit('finish')
       this.emit('end')
-      this.emit('close')
     }
   }
 
   [CHECKPATH] (entry) {
     if (this.strip) {
       const parts = normPath(entry.path).split('/')
-      if (parts.length < this.strip)
+      if (parts.length < this.strip) {
         return false
+      }
       entry.path = parts.slice(this.strip).join('/')
 
       if (entry.type === 'Link') {
         const linkparts = normPath(entry.linkpath).split('/')
-        if (linkparts.length >= this.strip)
+        if (linkparts.length >= this.strip) {
           entry.linkpath = linkparts.slice(this.strip).join('/')
-        else
+        } else {
           return false
+        }
       }
     }
 
@@ -267,10 +277,11 @@ class Unpack extends Parser {
       }
     }
 
-    if (path.isAbsolute(entry.path))
+    if (path.isAbsolute(entry.path)) {
       entry.absolute = normPath(path.resolve(entry.path))
-    else
+    } else {
       entry.absolute = normPath(path.resolve(this.cwd, entry.path))
+    }
 
     // if we somehow ended up with a path that escapes the cwd, and we are
     // not in preservePaths mode, then something is fishy!  This should have
@@ -292,32 +303,36 @@ class Unpack extends Parser {
     // may not replace the cwd with a different kind of thing entirely.
     if (entry.absolute === this.cwd &&
         entry.type !== 'Directory' &&
-        entry.type !== 'GNUDumpDir')
+        entry.type !== 'GNUDumpDir') {
       return false
+    }
 
     // only encode : chars that aren't drive letter indicators
     if (this.win32) {
       const { root: aRoot } = path.win32.parse(entry.absolute)
-      entry.absolute = aRoot + wc.encode(entry.absolute.substr(aRoot.length))
+      entry.absolute = aRoot + wc.encode(entry.absolute.slice(aRoot.length))
       const { root: pRoot } = path.win32.parse(entry.path)
-      entry.path = pRoot + wc.encode(entry.path.substr(pRoot.length))
+      entry.path = pRoot + wc.encode(entry.path.slice(pRoot.length))
     }
 
     return true
   }
 
   [ONENTRY] (entry) {
-    if (!this[CHECKPATH](entry))
+    if (!this[CHECKPATH](entry)) {
       return entry.resume()
+    }
 
     assert.equal(typeof entry.absolute, 'string')
 
     switch (entry.type) {
       case 'Directory':
       case 'GNUDumpDir':
-        if (entry.mode)
+        if (entry.mode) {
           entry.mode = entry.mode | 0o700
+        }
 
+      // eslint-disable-next-line no-fallthrough
       case 'File':
       case 'OldFile':
       case 'ContiguousFile':
@@ -337,10 +352,10 @@ class Unpack extends Parser {
     // Cwd has to exist, or else nothing works. That's serious.
     // Other errors are warnings, which raise the error in strict
     // mode, but otherwise continue on.
-    if (er.name === 'CwdError')
+    if (er.name === 'CwdError') {
       this.emit('error', er)
-    else {
-      this.warn('TAR_ENTRY_ERROR', er, {entry})
+    } else {
+      this.warn('TAR_ENTRY_ERROR', er, { entry })
       this[UNPEND]()
       entry.resume()
     }
@@ -390,8 +405,9 @@ class Unpack extends Parser {
       autoClose: false,
     })
     stream.on('error', er => {
-      if (stream.fd)
+      if (stream.fd) {
         fs.close(stream.fd, () => {})
+      }
 
       // flush all the data out so that we aren't left hanging
       // if the error wasn't actually fatal.  otherwise the parse
@@ -405,8 +421,9 @@ class Unpack extends Parser {
     const done = er => {
       if (er) {
         /* istanbul ignore else - we should always have a fd by now */
-        if (stream.fd)
+        if (stream.fd) {
           fs.close(stream.fd, () => {})
+        }
 
         this[ONERROR](er, entry)
         fullyDone()
@@ -415,10 +432,11 @@ class Unpack extends Parser {
 
       if (--actions === 0) {
         fs.close(stream.fd, er => {
-          if (er)
+          if (er) {
             this[ONERROR](er, entry)
-          else
+          } else {
             this[UNPEND]()
+          }
           fullyDone()
         })
       }
@@ -498,7 +516,7 @@ class Unpack extends Parser {
   [UNSUPPORTED] (entry) {
     entry.unsupported = true
     this.warn('TAR_ENTRY_UNSUPPORTED',
-      `unsupported entry type: ${entry.type}`, {entry})
+      `unsupported entry type: ${entry.type}`, { entry })
     entry.resume()
   }
 
@@ -540,8 +558,9 @@ class Unpack extends Parser {
   [CHECKFS] (entry) {
     this[PEND]()
     const paths = [entry.path]
-    if (entry.linkpath)
+    if (entry.linkpath) {
       paths.push(entry.linkpath)
+    }
     this.reservations.reserve(paths, done => this[CHECKFS2](entry, done))
   }
 
@@ -556,10 +575,11 @@ class Unpack extends Parser {
     // entry, it'll just fail to unpack, but a symlink to a directory, using an
     // 8.3 shortname or certain unicode attacks, can evade detection and lead
     // to arbitrary writes to anywhere on the system.
-    if (entry.type === 'SymbolicLink')
+    if (entry.type === 'SymbolicLink') {
       dropCache(this.dirCache)
-    else if (entry.type !== 'Directory')
+    } else if (entry.type !== 'Directory') {
       pruneCache(this.dirCache, entry.absolute)
+    }
   }
 
   [CHECKFS2] (entry, fullyDone) {
@@ -606,8 +626,9 @@ class Unpack extends Parser {
           done()
           return
         }
-        if (lstatEr || this[ISREUSABLE](entry, st))
+        if (lstatEr || this[ISREUSABLE](entry, st)) {
           return this[MAKEFS](null, entry, done)
+        }
 
         if (st.isDirectory()) {
           if (entry.type === 'Directory') {
@@ -615,8 +636,9 @@ class Unpack extends Parser {
               entry.mode &&
               (st.mode & 0o7777) !== entry.mode
             const afterChmod = er => this[MAKEFS](er, entry, done)
-            if (!needChmod)
+            if (!needChmod) {
               return afterChmod()
+            }
             return fs.chmod(entry.absolute, entry.mode, afterChmod)
           }
           // Not a dir entry, have to remove it.
@@ -634,18 +656,20 @@ class Unpack extends Parser {
 
         // not a dir, and not reusable
         // don't remove if the cwd, we want that error
-        if (entry.absolute === this.cwd)
+        if (entry.absolute === this.cwd) {
           return this[MAKEFS](null, entry, done)
+        }
 
         unlinkFile(entry.absolute, er =>
           this[MAKEFS](er, entry, done))
       })
     }
 
-    if (this[CHECKED_CWD])
+    if (this[CHECKED_CWD]) {
       start()
-    else
+    } else {
       checkCwd()
+    }
   }
 
   [MAKEFS] (er, entry, done) {
@@ -676,9 +700,9 @@ class Unpack extends Parser {
   [LINK] (entry, linkpath, link, done) {
     // XXX: get the type ('symlink' or 'junction') for windows
     fs[link](linkpath, entry.absolute, er => {
-      if (er)
+      if (er) {
         this[ONERROR](er, entry)
-      else {
+      } else {
         this[UNPEND]()
         entry.resume()
       }
@@ -704,8 +728,9 @@ class UnpackSync extends Unpack {
 
     if (!this[CHECKED_CWD]) {
       const er = this[MKDIR](this.cwd, this.dmode)
-      if (er)
+      if (er) {
         return this[ONERROR](er, entry)
+      }
       this[CHECKED_CWD] = true
     }
 
@@ -715,17 +740,20 @@ class UnpackSync extends Unpack {
       const parent = normPath(path.dirname(entry.absolute))
       if (parent !== this.cwd) {
         const mkParent = this[MKDIR](parent, this.dmode)
-        if (mkParent)
+        if (mkParent) {
           return this[ONERROR](mkParent, entry)
+        }
       }
     }
 
     const [lstatEr, st] = callSync(() => fs.lstatSync(entry.absolute))
-    if (st && (this.keep || this.newer && st.mtime > entry.mtime))
+    if (st && (this.keep || this.newer && st.mtime > entry.mtime)) {
       return this[SKIP](entry)
+    }
 
-    if (lstatEr || this[ISREUSABLE](entry, st))
+    if (lstatEr || this[ISREUSABLE](entry, st)) {
       return this[MAKEFS](null, entry)
+    }
 
     if (st.isDirectory()) {
       if (entry.type === 'Directory') {
@@ -759,8 +787,9 @@ class UnpackSync extends Unpack {
       } catch (e) {
         closeError = e
       }
-      if (er || closeError)
+      if (er || closeError) {
         this[ONERROR](er || closeError, entry)
+      }
       done()
     }
 

package/node_modules/tar/lib/update.js

@@ -9,14 +9,17 @@ const r = require('./replace.js')
 module.exports = (opt_, files, cb) => {
   const opt = hlo(opt_)
 
-  if (!opt.file)
+  if (!opt.file) {
     throw new TypeError('file is required')
+  }
 
-  if (opt.gzip)
+  if (opt.gzip) {
     throw new TypeError('cannot append to compressed archives')
+  }
 
-  if (!files || !Array.isArray(files) || !files.length)
+  if (!files || !Array.isArray(files) || !files.length) {
     throw new TypeError('no files or directories specified')
+  }
 
   files = Array.from(files)
 
@@ -27,8 +30,9 @@ module.exports = (opt_, files, cb) => {
 const mtimeFilter = opt => {
   const filter = opt.filter
 
-  if (!opt.mtimeCache)
+  if (!opt.mtimeCache) {
     opt.mtimeCache = new Map()
+  }
 
   opt.filter = filter ? (path, stat) =>
     filter(path, stat) && !(opt.mtimeCache.get(path) > stat.mtime)

package/node_modules/tar/lib/warn-mixin.js

@@ -1,10 +1,12 @@
 'use strict'
 module.exports = Base => class extends Base {
   warn (code, message, data = {}) {
-    if (this.file)
+    if (this.file) {
       data.file = this.file
-    if (this.cwd)
+    }
+    if (this.cwd) {
       data.cwd = this.cwd
+    }
     data.code = message instanceof Error && message.code || code
     data.tarCode = code
     if (!this.strict && data.recoverable !== false) {
@@ -13,9 +15,10 @@ module.exports = Base => class extends Base {
         message = message.message
       }
       this.emit('warn', data.tarCode, message, data)
-    } else if (message instanceof Error)
+    } else if (message instanceof Error) {
       this.emit('error', Object.assign(message, data))
-    else
+    } else {
       this.emit('error', Object.assign(new Error(`${code}: ${message}`), data))
+    }
   }
 }