cacache 12.0.2 → 13.0.1

package/lib/util/tmp.js

@@ -1,18 +1,20 @@
 'use strict'
 
-const BB = require('bluebird')
+const util = require('util')
 
 const figgyPudding = require('figgy-pudding')
 const fixOwner = require('./fix-owner')
 const path = require('path')
-const rimraf = BB.promisify(require('rimraf'))
+const rimraf = util.promisify(require('rimraf'))
 const uniqueFilename = require('unique-filename')
+const { disposer } = require('./disposer')
 
 const TmpOpts = figgyPudding({
   tmpPrefix: {}
 })
 
 module.exports.mkdir = mktmpdir
+
 function mktmpdir (cache, opts) {
   opts = TmpOpts(opts)
   const tmpTarget = uniqueFilename(path.join(cache, 'tmp'), opts.tmpPrefix)
@@ -22,16 +24,19 @@ function mktmpdir (cache, opts) {
 }
 
 module.exports.withTmp = withTmp
+
 function withTmp (cache, opts, cb) {
   if (!cb) {
     cb = opts
     opts = null
   }
   opts = TmpOpts(opts)
-  return BB.using(mktmpdir(cache, opts).disposer(rimraf), cb)
+
+  return disposer(mktmpdir(cache, opts), rimraf, cb)
 }
 
 module.exports.fix = fixtmpdir
+
 function fixtmpdir (cache) {
   return fixOwner(cache, path.join(cache, 'tmp'))
 }

package/lib/verify.js

@@ -1,19 +1,26 @@
 'use strict'
 
-const BB = require('bluebird')
+const util = require('util')
 
+const pMap = require('p-map')
 const contentPath = require('./content/path')
 const figgyPudding = require('figgy-pudding')
-const finished = BB.promisify(require('mississippi').finished)
 const fixOwner = require('./util/fix-owner')
 const fs = require('graceful-fs')
-const glob = BB.promisify(require('glob'))
+const fsm = require('fs-minipass')
+const glob = util.promisify(require('glob'))
 const index = require('./entry-index')
 const path = require('path')
-const rimraf = BB.promisify(require('rimraf'))
+const rimraf = util.promisify(require('rimraf'))
 const ssri = require('ssri')
 
-BB.promisifyAll(fs)
+const hasOwnProperty = (obj, key) =>
+  Object.prototype.hasOwnProperty.call(obj, key)
+
+const stat = util.promisify(fs.stat)
+const truncate = util.promisify(fs.truncate)
+const writeFile = util.promisify(fs.writeFile)
+const readFile = util.promisify(fs.readFile)
 
 const VerifyOpts = figgyPudding({
   concurrency: {
@@ -26,10 +33,12 @@ const VerifyOpts = figgyPudding({
 })
 
 module.exports = verify
+
 function verify (cache, opts) {
   opts = VerifyOpts(opts)
   opts.log.silly('verify', 'verifying cache at', cache)
-  return BB.reduce([
+
+  const steps = [
     markStartTime,
     fixPerms,
     garbageCollect,
@@ -37,38 +46,57 @@ function verify (cache, opts) {
     cleanTmp,
     writeVerifile,
     markEndTime
-  ], (stats, step, i) => {
-    const label = step.name || `step #${i}`
-    const start = new Date()
-    return BB.resolve(step(cache, opts)).then(s => {
-      s && Object.keys(s).forEach(k => {
-        stats[k] = s[k]
+  ]
+
+  return steps
+    .reduce((promise, step, i) => {
+      const label = step.name || `step #${i}`
+      const start = new Date()
+      return promise.then((stats) => {
+        return step(cache, opts).then((s) => {
+          s &&
+            Object.keys(s).forEach((k) => {
+              stats[k] = s[k]
+            })
+          const end = new Date()
+          if (!stats.runTime) {
+            stats.runTime = {}
+          }
+          stats.runTime[label] = end - start
+          return Promise.resolve(stats)
+        })
       })
-      const end = new Date()
-      if (!stats.runTime) { stats.runTime = {} }
-      stats.runTime[label] = end - start
+    }, Promise.resolve({}))
+    .then((stats) => {
+      stats.runTime.total = stats.endTime - stats.startTime
+      opts.log.silly(
+        'verify',
+        'verification finished for',
+        cache,
+        'in',
+        `${stats.runTime.total}ms`
+      )
       return stats
     })
-  }, {}).tap(stats => {
-    stats.runTime.total = stats.endTime - stats.startTime
-    opts.log.silly('verify', 'verification finished for', cache, 'in', `${stats.runTime.total}ms`)
-  })
 }
 
 function markStartTime (cache, opts) {
-  return { startTime: new Date() }
+  return Promise.resolve({ startTime: new Date() })
 }
 
 function markEndTime (cache, opts) {
-  return { endTime: new Date() }
+  return Promise.resolve({ endTime: new Date() })
 }
 
 function fixPerms (cache, opts) {
   opts.log.silly('verify', 'fixing cache permissions')
-  return fixOwner.mkdirfix(cache, cache).then(() => {
-    // TODO - fix file permissions too
-    return fixOwner.chownr(cache, cache)
-  }).then(() => null)
+  return fixOwner
+    .mkdirfix(cache, cache)
+    .then(() => {
+      // TODO - fix file permissions too
+      return fixOwner.chownr(cache, cache)
+    })
+    .then(() => null)
 }
 
 // Implements a naive mark-and-sweep tracing garbage collector.
@@ -84,85 +112,104 @@ function garbageCollect (cache, opts) {
   opts.log.silly('verify', 'garbage collecting content')
   const indexStream = index.lsStream(cache)
   const liveContent = new Set()
-  indexStream.on('data', entry => {
-    if (opts.filter && !opts.filter(entry)) { return }
+  indexStream.on('data', (entry) => {
+    if (opts.filter && !opts.filter(entry)) {
+      return
+    }
     liveContent.add(entry.integrity.toString())
   })
-  return finished(indexStream).then(() => {
-    const contentDir = contentPath._contentDir(cache)
+  return new Promise((resolve, reject) => {
+    indexStream.on('end', resolve).on('error', reject)
+  }).then(() => {
+    const contentDir = contentPath.contentDir(cache)
     return glob(path.join(contentDir, '**'), {
       follow: false,
       nodir: true,
       nosort: true
-    }).then(files => {
-      return BB.resolve({
+    }).then((files) => {
+      return Promise.resolve({
         verifiedContent: 0,
         reclaimedCount: 0,
         reclaimedSize: 0,
         badContentCount: 0,
         keptSize: 0
-      }).tap((stats) => BB.map(files, (f) => {
-        const split = f.split(/[/\\]/)
-        const digest = split.slice(split.length - 3).join('')
-        const algo = split[split.length - 4]
-        const integrity = ssri.fromHex(digest, algo)
-        if (liveContent.has(integrity.toString())) {
-          return verifyContent(f, integrity).then(info => {
-            if (!info.valid) {
-              stats.reclaimedCount++
-              stats.badContentCount++
-              stats.reclaimedSize += info.size
+      }).then((stats) =>
+        pMap(
+          files,
+          (f) => {
+            const split = f.split(/[/\\]/)
+            const digest = split.slice(split.length - 3).join('')
+            const algo = split[split.length - 4]
+            const integrity = ssri.fromHex(digest, algo)
+            if (liveContent.has(integrity.toString())) {
+              return verifyContent(f, integrity).then((info) => {
+                if (!info.valid) {
+                  stats.reclaimedCount++
+                  stats.badContentCount++
+                  stats.reclaimedSize += info.size
+                } else {
+                  stats.verifiedContent++
+                  stats.keptSize += info.size
+                }
+                return stats
+              })
             } else {
-              stats.verifiedContent++
-              stats.keptSize += info.size
+              // No entries refer to this content. We can delete.
+              stats.reclaimedCount++
+              return stat(f).then((s) => {
+                return rimraf(f).then(() => {
+                  stats.reclaimedSize += s.size
+                  return stats
+                })
+              })
             }
-            return stats
-          })
-        } else {
-          // No entries refer to this content. We can delete.
-          stats.reclaimedCount++
-          return fs.statAsync(f).then(s => {
-            return rimraf(f).then(() => {
-              stats.reclaimedSize += s.size
-              return stats
-            })
-          })
-        }
-      }, { concurrency: opts.concurrency }))
+          },
+          { concurrency: opts.concurrency }
+        ).then(() => stats)
+      )
     })
   })
 }
 
 function verifyContent (filepath, sri) {
-  return fs.statAsync(filepath).then(stat => {
-    const contentInfo = {
-      size: stat.size,
-      valid: true
-    }
-    return ssri.checkStream(
-      fs.createReadStream(filepath),
-      sri
-    ).catch(err => {
-      if (err.code !== 'EINTEGRITY') { throw err }
-      return rimraf(filepath).then(() => {
-        contentInfo.valid = false
-      })
-    }).then(() => contentInfo)
-  }).catch({ code: 'ENOENT' }, () => ({ size: 0, valid: false }))
+  return stat(filepath)
+    .then((s) => {
+      const contentInfo = {
+        size: s.size,
+        valid: true
+      }
+      return ssri
+        .checkStream(new fsm.ReadStream(filepath), sri)
+        .catch((err) => {
+          if (err.code !== 'EINTEGRITY') {
+            throw err
+          }
+          return rimraf(filepath).then(() => {
+            contentInfo.valid = false
+          })
+        })
+        .then(() => contentInfo)
+    })
+    .catch((err) => {
+      if (err.code === 'ENOENT') {
+        return { size: 0, valid: false }
+      }
+      throw err
+    })
 }
 
 function rebuildIndex (cache, opts) {
   opts.log.silly('verify', 'rebuilding index')
-  return index.ls(cache).then(entries => {
+  return index.ls(cache).then((entries) => {
     const stats = {
       missingContent: 0,
       rejectedEntries: 0,
       totalEntries: 0
     }
     const buckets = {}
-    for (let k in entries) {
-      if (entries.hasOwnProperty(k)) {
-        const hashed = index._hashKey(k)
+    for (const k in entries) {
+      if (hasOwnProperty(entries, k)) {
+        const hashed = index.hashKey(k)
         const entry = entries[k]
         const excluded = opts.filter && !opts.filter(entry)
         excluded && stats.rejectedEntries++
@@ -172,35 +219,51 @@ function rebuildIndex (cache, opts) {
           // skip
         } else if (excluded) {
           buckets[hashed] = []
-          buckets[hashed]._path = index._bucketPath(cache, k)
+          buckets[hashed]._path = index.bucketPath(cache, k)
         } else {
           buckets[hashed] = [entry]
-          buckets[hashed]._path = index._bucketPath(cache, k)
+          buckets[hashed]._path = index.bucketPath(cache, k)
         }
       }
     }
-    return BB.map(Object.keys(buckets), key => {
-      return rebuildBucket(cache, buckets[key], stats, opts)
-    }, { concurrency: opts.concurrency }).then(() => stats)
+    return pMap(
+      Object.keys(buckets),
+      (key) => {
+        return rebuildBucket(cache, buckets[key], stats, opts)
+      },
+      { concurrency: opts.concurrency }
+    ).then(() => stats)
   })
 }
 
 function rebuildBucket (cache, bucket, stats, opts) {
-  return fs.truncateAsync(bucket._path).then(() => {
+  return truncate(bucket._path).then(() => {
     // This needs to be serialized because cacache explicitly
     // lets very racy bucket conflicts clobber each other.
-    return BB.mapSeries(bucket, entry => {
-      const content = contentPath(cache, entry.integrity)
-      return fs.statAsync(content).then(() => {
-        return index.insert(cache, entry.key, entry.integrity, {
-          metadata: entry.metadata,
-          size: entry.size
-        }).then(() => { stats.totalEntries++ })
-      }).catch({ code: 'ENOENT' }, () => {
-        stats.rejectedEntries++
-        stats.missingContent++
+    return bucket.reduce((promise, entry) => {
+      return promise.then(() => {
+        const content = contentPath(cache, entry.integrity)
+        return stat(content)
+          .then(() => {
+            return index
+              .insert(cache, entry.key, entry.integrity, {
+                metadata: entry.metadata,
+                size: entry.size
+              })
+              .then(() => {
+                stats.totalEntries++
+              })
+          })
+          .catch((err) => {
+            if (err.code === 'ENOENT') {
+              stats.rejectedEntries++
+              stats.missingContent++
+              return
+            }
+            throw err
+          })
       })
-    })
+    }, Promise.resolve())
   })
 }
 
@@ -213,15 +276,16 @@ function writeVerifile (cache, opts) {
   const verifile = path.join(cache, '_lastverified')
   opts.log.silly('verify', 'writing verifile to ' + verifile)
   try {
-    return fs.writeFileAsync(verifile, '' + (+(new Date())))
+    return writeFile(verifile, '' + +new Date())
   } finally {
     fixOwner.chownr.sync(cache, verifile)
   }
 }
 
 module.exports.lastRun = lastRun
+
 function lastRun (cache) {
-  return fs.readFileAsync(
-    path.join(cache, '_lastverified'), 'utf8'
-  ).then(data => new Date(+data))
+  return readFile(path.join(cache, '_lastverified'), 'utf8').then(
+    (data) => new Date(+data)
+  )
 }

package/ls.js

@@ -1,6 +1,6 @@
 'use strict'
 
-var index = require('./lib/entry-index')
+const index = require('./lib/entry-index')
 
 module.exports = index.ls
 module.exports.stream = index.lsStream

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cacache",
-  "version": "12.0.2",
+  "version": "13.0.1",
   "cache-version": {
     "content": "2",
     "index": "5"
@@ -18,7 +18,7 @@
     "postrelease": "npm publish && git push --follow-tags",
     "pretest": "standard",
     "release": "standard-version -s",
-    "test": "cross-env CACACHE_UPDATE_LOCALE_FILES=true tap --coverage --nyc-arg=--all -J test/*.js",
+    "test": "tap test/*.js",
     "test-docker": "docker run -it --rm --name pacotest -v \"$PWD\":/tmp -w /tmp node:latest npm test",
     "update-coc": "weallbehave -o . && git add CODE_OF_CONDUCT.md && git commit -m 'docs(coc): updated CODE_OF_CONDUCT.md'",
     "update-contrib": "weallcontribute -o . && git add CONTRIBUTING.md && git commit -m 'docs(contributing): updated CONTRIBUTING.md'"
@@ -58,40 +58,38 @@
   ],
   "license": "ISC",
   "dependencies": {
-    "bluebird": "^3.5.5",
-    "chownr": "^1.1.1",
+    "chownr": "^1.1.2",
     "figgy-pudding": "^3.5.1",
+    "fs-minipass": "^2.0.0",
     "glob": "^7.1.4",
-    "graceful-fs": "^4.1.15",
-    "infer-owner": "^1.0.3",
+    "graceful-fs": "^4.2.2",
+    "infer-owner": "^1.0.4",
     "lru-cache": "^5.1.1",
-    "mississippi": "^3.0.0",
+    "minipass": "^3.0.0",
+    "minipass-collect": "^1.0.2",
+    "minipass-flush": "^1.0.5",
+    "minipass-pipeline": "^1.2.2",
     "mkdirp": "^0.5.1",
     "move-concurrently": "^1.0.1",
+    "p-map": "^3.0.0",
     "promise-inflight": "^1.0.1",
-    "rimraf": "^2.6.3",
-    "ssri": "^6.0.1",
-    "unique-filename": "^1.1.1",
-    "y18n": "^4.0.0"
+    "rimraf": "^2.7.1",
+    "ssri": "^7.0.0",
+    "unique-filename": "^1.1.1"
   },
   "devDependencies": {
     "benchmark": "^2.1.4",
     "chalk": "^2.4.2",
-    "cross-env": "^5.1.4",
+    "cross-env": "^5.2.1",
     "require-inject": "^1.4.4",
-    "standard": "^12.0.1",
-    "standard-version": "^6.0.1",
+    "standard": "^14.3.0",
+    "standard-version": "^7.0.0",
     "tacks": "^1.3.0",
-    "tap": "^12.7.0",
+    "tap": "^14.6.9",
     "weallbehave": "^1.2.0",
     "weallcontribute": "^1.0.9"
   },
-  "config": {
-    "nyc": {
-      "exclude": [
-        "node_modules/**",
-        "test/**"
-      ]
-    }
+  "engines": {
+    "node": ">= 8"
   }
 }

package/put.js

@@ -4,7 +4,9 @@ const figgyPudding = require('figgy-pudding')
 const index = require('./lib/entry-index')
 const memo = require('./lib/memoization')
 const write = require('./lib/content/write')
-const to = require('mississippi').to
+const Flush = require('minipass-flush')
+const { PassThrough } = require('minipass-collect')
+const Pipeline = require('minipass-pipeline')
 
 const PutOpts = figgyPudding({
   algorithms: {
@@ -23,64 +25,70 @@ const PutOpts = figgyPudding({
 })
 
 module.exports = putData
+
 function putData (cache, key, data, opts) {
   opts = PutOpts(opts)
-  return write(cache, data, opts).then(res => {
-    return index.insert(
-      cache, key, res.integrity, opts.concat({ size: res.size })
-    ).then(entry => {
-      if (opts.memoize) {
-        memo.put(cache, entry, data, opts)
-      }
-      return res.integrity
-    })
+  return write(cache, data, opts).then((res) => {
+    return index
+      .insert(cache, key, res.integrity, opts.concat({ size: res.size }))
+      .then((entry) => {
+        if (opts.memoize) {
+          memo.put(cache, entry, data, opts)
+        }
+        return res.integrity
+      })
   })
 }
 
 module.exports.stream = putStream
+
 function putStream (cache, key, opts) {
   opts = PutOpts(opts)
   let integrity
   let size
-  const contentStream = write.stream(
-    cache, opts
-  ).on('integrity', int => {
-    integrity = int
-  }).on('size', s => {
-    size = s
-  })
+
   let memoData
-  let memoTotal = 0
-  const stream = to((chunk, enc, cb) => {
-    contentStream.write(chunk, enc, () => {
-      if (opts.memoize) {
-        if (!memoData) { memoData = [] }
-        memoData.push(chunk)
-        memoTotal += chunk.length
-      }
-      cb()
+  const pipeline = new Pipeline()
+  // first item in the pipeline is the memoizer, because we need
+  // that to end first and get the collected data.
+  if (opts.memoize) {
+    const memoizer = new PassThrough().on('collect', data => {
+      memoData = data
     })
-  }, cb => {
-    contentStream.end(() => {
-      index.insert(cache, key, integrity, opts.concat({ size })).then(entry => {
-        if (opts.memoize) {
-          memo.put(cache, entry, Buffer.concat(memoData, memoTotal), opts)
-        }
-        stream.emit('integrity', integrity)
-        cb()
-      })
+    pipeline.push(memoizer)
+  }
+
+  // contentStream is a write-only, not a passthrough
+  // no data comes out of it.
+  const contentStream = write.stream(cache, opts)
+    .on('integrity', (int) => {
+      integrity = int
     })
-  })
-  let erred = false
-  stream.once('error', err => {
-    if (erred) { return }
-    erred = true
-    contentStream.emit('error', err)
-  })
-  contentStream.once('error', err => {
-    if (erred) { return }
-    erred = true
-    stream.emit('error', err)
-  })
-  return stream
+    .on('size', (s) => {
+      size = s
+    })
+
+  pipeline.push(contentStream)
+
+  // last but not least, we write the index and emit hash and size,
+  // and memoize if we're doing that
+  pipeline.push(new Flush({
+    flush () {
+      return index
+        .insert(cache, key, integrity, opts.concat({ size }))
+        .then((entry) => {
+          if (opts.memoize && memoData) {
+            memo.put(cache, entry, memoData, opts)
+          }
+          if (integrity) {
+            pipeline.emit('integrity', integrity)
+          }
+          if (size) {
+            pipeline.emit('size', size)
+          }
+        })
+    }
+  }))
+
+  return pipeline
 }

package/rm.js

@@ -1,27 +1,30 @@
 'use strict'
 
-const BB = require('bluebird')
+const util = require('util')
 
 const index = require('./lib/entry-index')
 const memo = require('./lib/memoization')
 const path = require('path')
-const rimraf = BB.promisify(require('rimraf'))
+const rimraf = util.promisify(require('rimraf'))
 const rmContent = require('./lib/content/rm')
 
 module.exports = entry
 module.exports.entry = entry
+
 function entry (cache, key) {
   memo.clearMemoized()
   return index.delete(cache, key)
 }
 
 module.exports.content = content
+
 function content (cache, integrity) {
   memo.clearMemoized()
   return rmContent(cache, integrity)
 }
 
 module.exports.all = all
+
 function all (cache) {
   memo.clearMemoized()
   return rimraf(path.join(cache, '*(content-*|index-*)'))