patched v6.0.5

Author: seal-devops

.travis.yml

@@ -1,6 +1,6 @@
 language: node_js
 
 node_js:
-  - node
+  - '14'
   - 12
   - 10

lib/mkdir.js

@@ -8,6 +8,7 @@ const mkdirp = require('mkdirp')
 const fs = require('fs')
 const path = require('path')
 const chownr = require('chownr')
+const normPath = require('./normalize-windows-path.js')
 
 class SymlinkError extends Error {
   constructor (symlink, path) {
@@ -33,7 +34,11 @@ class CwdError extends Error {
   }
 }
 
-const mkdir = module.exports = (dir, opt, cb) => {
+const cGet = (cache, key) => cache.get(normPath(key))
+const cSet = (cache, key, val) => cache.set(normPath(key), val)
+
+module.exports = (dir, opt, cb) => {
+  dir = normPath(dir)
   // if there's any overlap between mask and mode,
   // then we'll need an explicit chmod
   const umask = opt.umask
@@ -44,18 +49,18 @@ const mkdir = module.exports = (dir, opt, cb) => {
   const gid = opt.gid
   const doChown = typeof uid === 'number' &&
     typeof gid === 'number' &&
-    ( uid !== opt.processUid || gid !== opt.processGid )
+    (uid !== opt.processUid || gid !== opt.processGid)
 
   const preserve = opt.preserve
   const unlink = opt.unlink
   const cache = opt.cache
-  const cwd = opt.cwd
+  const cwd = normPath(opt.cwd)
 
   const done = (er, created) => {
     if (er)
       cb(er)
     else {
-      cache.set(dir, true)
+      cSet(cache, dir, true)
       if (created && doChown)
         chownr(created, uid, gid, er => done(er))
       else if (needChmod)
@@ -65,21 +70,22 @@ const mkdir = module.exports = (dir, opt, cb) => {
     }
   }
 
-  if (cache && cache.get(dir) === true)
+  if (cache && cGet(cache, dir) === true)
     return done()
 
-  if (dir === cwd)
+  if (dir === cwd) {
     return fs.stat(dir, (er, st) => {
       if (er || !st.isDirectory())
         er = new CwdError(dir, er && er.code || 'ENOTDIR')
       done(er)
     })
+  }
 
   if (preserve)
     return mkdirp(dir, {mode}).then(made => done(null, made), done)
 
   const sub = path.relative(cwd, dir)
-  const parts = sub.split(/\/|\\/)
+  const parts = sub.split('/')
   mkdir_(cwd, parts, mode, cache, unlink, cwd, null, done)
 }
 
@@ -88,7 +94,7 @@ const mkdir_ = (base, parts, mode, cache, unlink, cwd, created, cb) => {
     return cb(null, created)
   const p = parts.shift()
   const part = base + '/' + p
-  if (cache.get(part))
+  if (cGet(cache, part))
     return mkdir_(part, parts, mode, cache, unlink, cwd, created, cb)
   fs.mkdir(part, mode, onmkdir(part, parts, mode, cache, unlink, cwd, created, cb))
 }
@@ -104,13 +110,13 @@ const onmkdir = (part, parts, mode, cache, unlink, cwd, created, cb) => er => {
         cb(statEr)
       else if (st.isDirectory())
         mkdir_(part, parts, mode, cache, unlink, cwd, created, cb)
-      else if (unlink)
+      else if (unlink) {
         fs.unlink(part, er => {
           if (er)
             return cb(er)
           fs.mkdir(part, mode, onmkdir(part, parts, mode, cache, unlink, cwd, created, cb))
         })
-      else if (st.isSymbolicLink())
+      } else if (st.isSymbolicLink())
         return cb(new SymlinkError(part, part + '/' + parts.join('/')))
       else
         cb(er)
@@ -121,7 +127,8 @@ const onmkdir = (part, parts, mode, cache, unlink, cwd, created, cb) => er => {
   }
 }
 
-const mkdirSync = module.exports.sync = (dir, opt) => {
+module.exports.sync = (dir, opt) => {
+  dir = normPath(dir)
   // if there's any overlap between mask and mode,
   // then we'll need an explicit chmod
   const umask = opt.umask
@@ -132,22 +139,22 @@ const mkdirSync = module.exports.sync = (dir, opt) => {
   const gid = opt.gid
   const doChown = typeof uid === 'number' &&
     typeof gid === 'number' &&
-    ( uid !== opt.processUid || gid !== opt.processGid )
+    (uid !== opt.processUid || gid !== opt.processGid)
 
   const preserve = opt.preserve
   const unlink = opt.unlink
   const cache = opt.cache
-  const cwd = opt.cwd
+  const cwd = normPath(opt.cwd)
 
   const done = (created) => {
-    cache.set(dir, true)
+    cSet(cache, dir, true)
     if (created && doChown)
       chownr.sync(created, uid, gid)
     if (needChmod)
       fs.chmodSync(dir, mode)
   }
 
-  if (cache && cache.get(dir) === true)
+  if (cache && cGet(cache, dir) === true)
     return done()
 
   if (dir === cwd) {
@@ -169,33 +176,32 @@ const mkdirSync = module.exports.sync = (dir, opt) => {
     return done(mkdirp.sync(dir, mode))
 
   const sub = path.relative(cwd, dir)
-  const parts = sub.split(/\/|\\/)
+  const parts = sub.split('/')
   let created = null
   for (let p = parts.shift(), part = cwd;
-       p && (part += '/' + p);
-       p = parts.shift()) {
-
-    if (cache.get(part))
+    p && (part += '/' + p);
+    p = parts.shift()) {
+    if (cGet(cache, part))
       continue
 
     try {
       fs.mkdirSync(part, mode)
       created = created || part
-      cache.set(part, true)
+      cSet(cache, part, true)
     } catch (er) {
       if (er.path && path.dirname(er.path) === cwd &&
           (er.code === 'ENOTDIR' || er.code === 'ENOENT'))
         return new CwdError(cwd, er.code)
 
       const st = fs.lstatSync(part)
       if (st.isDirectory()) {
-        cache.set(part, true)
+        cSet(cache, part, true)
         continue
       } else if (unlink) {
         fs.unlinkSync(part)
         fs.mkdirSync(part, mode)
         created = created || part
-        cache.set(part, true)
+        cSet(cache, part, true)
         continue
       } else if (st.isSymbolicLink())
         return new SymlinkError(part, part + '/' + parts.join('/'))

lib/normalize-windows-path.js

@@ -0,0 +1,8 @@
+// on windows, either \ or / are valid directory separators.
+// on unix, \ is a valid character in filenames.
+// so, on windows, and only on windows, we replace all \ chars with /,
+// so that we can use / as our one and only directory separator char.
+
+const platform = process.env.TESTING_TAR_FAKE_PLATFORM || process.platform
+module.exports = platform !== 'win32' ? p => p
+  : p => p.replace(/\\/g, '/')

lib/pack.js

@@ -54,6 +54,8 @@ const ONDRAIN = Symbol('ondrain')
 const fs = require('fs')
 const path = require('path')
 const warner = require('./warn-mixin.js')
+const normPath = require('./normalize-windows-path.js')
+const platform = process.env.TESTING_TAR_FAKE_PLATFORM || process.platform
 
 const Pack = warner(class Pack extends MiniPass {
   constructor (opt) {
@@ -66,7 +68,7 @@ const Pack = warner(class Pack extends MiniPass {
     this.preservePaths = !!opt.preservePaths
     this.strict = !!opt.strict
     this.noPax = !!opt.noPax
-    this.prefix = (opt.prefix || '').replace(/(\\|\/)+$/, '')
+    this.prefix = normPath(opt.prefix || '').replace(/\/+$/, '')
     this.linkCache = opt.linkCache || new Map()
     this.statCache = opt.statCache || new Map()
     this.readdirCache = opt.readdirCache || new Map()
@@ -133,7 +135,7 @@ const Pack = warner(class Pack extends MiniPass {
   }
 
   [ADDTARENTRY] (p) {
-    const absolute = path.resolve(this.cwd, p.path)
+    const absolute = normPath(path.resolve(this.cwd, p.path))
     if (this.prefix)
       p.path = this.prefix + '/' + p.path.replace(/^\.(\/+|$)/, '')
 
@@ -152,9 +154,10 @@ const Pack = warner(class Pack extends MiniPass {
   }
 
   [ADDFSENTRY] (p) {
-    const absolute = path.resolve(this.cwd, p)
-    if (this.prefix)
+    const absolute = normPath(path.resolve(this.cwd, p))
+    if (this.prefix){
       p = this.prefix + '/' + p.replace(/^\.(\/+|$)/, '')
+    }
 
     this[QUEUE].push(new PackJob(p, absolute))
     this[PROCESS]()

lib/path-reservations.js

@@ -7,6 +7,7 @@
 // while still allowing maximal safe parallelization.
 
 const assert = require('assert')
+const normPath = require('./normalize-windows-path.js')
 
 module.exports = () => {
   // path => [function or Set]
@@ -20,8 +21,9 @@ module.exports = () => {
   // return a set of parent dirs for a given path
   const { join } = require('path')
   const getDirs = path =>
-    join(path).split(/[\\\/]/).slice(0, -1).reduce((set, path) =>
-      set.length ? set.concat(join(set[set.length-1], path)) : [path], [])
+    normPath(join(path)).split('/').slice(0, -1).reduce((set, path) =>
+      set.length ? set.concat(normPath(join(set[set.length - 1], path)))
+        : [path], [])
 
   // functions currently running
   const running = new Set()

lib/strip-absolute-path.js

@@ -0,0 +1,16 @@
+// unix absolute paths are also absolute on win32, so we use this for both
+const { isAbsolute, parse } = require('path').win32
+
+// returns [root, stripped]
+module.exports = path => {
+  let r = ''
+  let parsed = parse(path)
+  while (isAbsolute(path) || parsed.root) {
+    // windows will think that //x/y/z has a "root" of //x/y/
+    const root = path.charAt(0) === '/' && path.slice(0, 4) !== '//?/' ? '/' : parsed.root
+    path = path.substr(root.length)
+    r += root
+    parsed = parse(path)
+  }
+  return [r, path]
+}

lib/strip-trailing-slashes.js

@@ -0,0 +1,24 @@
+// this is the only approach that was significantly faster than using
+// str.replace(/\/+$/, '') for strings ending with a lot of / chars and
+// containing multiple / chars.
+const batchStrings = [
+    '/'.repeat(1024),
+    '/'.repeat(512),
+    '/'.repeat(256),
+    '/'.repeat(128),
+    '/'.repeat(64),
+    '/'.repeat(32),
+    '/'.repeat(16),
+    '/'.repeat(8),
+    '/'.repeat(4),
+    '/'.repeat(2),
+    '/',
+  ]
+
+  module.exports = str => {
+    for (const s of batchStrings) {
+      while (str.length >= s.length && str.slice(-1 * s.length) === s)
+        str = str.slice(0, -1 * s.length)
+    }
+    return str
+  }