nyc 13.2.0 → 14.0.0

package/index.js

@@ -2,9 +2,8 @@
 
 /* global __coverage__ */
 
-const arrify = require('arrify')
 const cachingTransform = require('caching-transform')
-const util = require('util')
+const cpFile = require('cp-file')
 const findCacheDir = require('find-cache-dir')
 const fs = require('fs')
 const glob = require('glob')
@@ -21,21 +20,16 @@ const resolveFrom = require('resolve-from')
 const rimraf = require('rimraf')
 const SourceMaps = require('./lib/source-maps')
 const testExclude = require('test-exclude')
+const util = require('util')
 const uuid = require('uuid/v4')
 
 const debugLog = util.debuglog('nyc')
 
-var ProcessInfo
-try {
-  ProcessInfo = require('./lib/process.covered.js')
-} catch (e) {
-  /* istanbul ignore next */
-  ProcessInfo = require('./lib/process.js')
-}
+const ProcessInfo = require('./lib/process.js')
 
 /* istanbul ignore next */
-if (/index\.covered\.js$/.test(__filename)) {
-  require('./lib/self-coverage-helper')
+if (/self-coverage/.test(__dirname)) {
+  require('../self-coverage-helper')
 }
 
 function NYC (config) {
@@ -50,15 +44,22 @@ function NYC (config) {
   this._showProcessTree = config.showProcessTree || false
   this._eagerInstantiation = config.eager || false
   this.cwd = config.cwd || process.cwd()
-  this.reporter = arrify(config.reporter || 'text')
+  this.reporter = [].concat(config.reporter || 'text')
 
   this.cacheDirectory = (config.cacheDir && path.resolve(config.cacheDir)) || findCacheDir({ name: 'nyc', cwd: this.cwd })
   this.cache = Boolean(this.cacheDirectory && config.cache)
 
+  this.extensions = [].concat(config.extension || [])
+    .concat('.js')
+    .map(ext => ext.toLowerCase())
+    .filter((item, pos, arr) => arr.indexOf(item) === pos)
+
   this.exclude = testExclude({
     cwd: this.cwd,
     include: config.include,
-    exclude: config.exclude
+    exclude: config.exclude,
+    excludeNodeModules: config.excludeNodeModules !== false,
+    extension: this.extensions
   })
 
   this.sourceMaps = new SourceMaps({
@@ -67,19 +68,12 @@ function NYC (config) {
   })
 
   // require extensions can be provided as config in package.json.
-  this.require = arrify(config.require)
+  this.require = [].concat(config.require || [])
 
-  this.extensions = arrify(config.extension).concat('.js').map(function (ext) {
-    return ext.toLowerCase()
-  }).filter(function (item, pos, arr) {
-    // avoid duplicate extensions
-    return arr.indexOf(item) === pos
-  })
-
-  this.transforms = this.extensions.reduce(function (transforms, ext) {
+  this.transforms = this.extensions.reduce((transforms, ext) => {
     transforms[ext] = this._createTransform(ext)
     return transforms
-  }.bind(this), {})
+  }, {})
 
   this.hookRequire = config.hookRequire
   this.hookRunInContext = config.hookRunInContext
@@ -94,7 +88,7 @@ function NYC (config) {
 
 NYC.prototype._createTransform = function (ext) {
   var opts = {
-    salt: Hash.salt,
+    salt: Hash.salt(this.config),
     hashData: (input, metadata) => [metadata.filename],
     onHash: (input, metadata, hash) => {
       this.hashCache[metadata.filename] = hash
@@ -118,17 +112,10 @@ NYC.prototype._disableCachingTransform = function () {
 }
 
 NYC.prototype._loadAdditionalModules = function () {
-  var _this = this
-  this.require.forEach(function (r) {
-    // first attempt to require the module relative to
-    // the directory being instrumented.
-    var p = resolveFrom.silent(_this.cwd, r)
-    if (p) {
-      require(p)
-      return
-    }
-    // now try other locations, .e.g, the nyc node_modules folder.
-    require(r)
+  this.require.forEach(requireModule => {
+    // Attempt to require the module relative to the directory being instrumented.
+    // Then try other locations, e.g. the nyc node_modules folder.
+    require(resolveFrom.silent(this.cwd, requireModule) || requireModule)
   })
 }
 
@@ -137,26 +124,19 @@ NYC.prototype.instrumenter = function () {
 }
 
 NYC.prototype._createInstrumenter = function () {
-  return this._instrumenterLib(this.cwd, {
+  return this._instrumenterLib({
     ignoreClassMethods: [].concat(this.config.ignoreClassMethod).filter(a => a),
     produceSourceMap: this.config.produceSourceMap,
     compact: this.config.compact,
     preserveComments: this.config.preserveComments,
     esModules: this.config.esModules,
-    plugins: this.config.plugins
+    plugins: this.config.parserPlugins
   })
 }
 
 NYC.prototype.addFile = function (filename) {
-  var relFile = path.relative(this.cwd, filename)
-  var source = this._readTranspiledSource(path.resolve(this.cwd, filename))
-  var instrumentedSource = this._maybeInstrumentSource(source, filename, relFile)
-
-  return {
-    instrument: !!instrumentedSource,
-    relFile: relFile,
-    content: instrumentedSource || source
-  }
+  const source = this._readTranspiledSource(filename)
+  this._maybeInstrumentSource(source, filename)
 }
 
 NYC.prototype._readTranspiledSource = function (filePath) {
@@ -174,21 +154,16 @@ NYC.prototype._readTranspiledSource = function (filePath) {
 }
 
 NYC.prototype.addAllFiles = function () {
-  var _this = this
-
   this._loadAdditionalModules()
 
   this.fakeRequire = true
-  this.walkAllFiles(this.cwd, function (filename) {
-    filename = path.resolve(_this.cwd, filename)
-    if (_this.exclude.shouldInstrument(filename)) {
-      _this.addFile(filename)
-      var coverage = coverageFinder()
-      var lastCoverage = _this.instrumenter().lastFileCoverage()
-      if (lastCoverage) {
-        filename = lastCoverage.path
-        coverage[filename] = lastCoverage
-      }
+  this.exclude.globSync(this.cwd).forEach(relFile => {
+    const filename = path.resolve(this.cwd, relFile)
+    this.addFile(filename)
+    const coverage = coverageFinder()
+    const lastCoverage = this.instrumenter().lastFileCoverage()
+    if (lastCoverage) {
+      coverage[lastCoverage.path] = lastCoverage
     }
   })
   this.fakeRequire = false
@@ -197,41 +172,38 @@ NYC.prototype.addAllFiles = function () {
 }
 
 NYC.prototype.instrumentAllFiles = function (input, output, cb) {
-  var _this = this
-  var inputDir = '.' + path.sep
-  var visitor = function (filename) {
-    var ext
-    var transform
-    var inFile = path.resolve(inputDir, filename)
-    var code = fs.readFileSync(inFile, 'utf-8')
-
-    for (ext in _this.transforms) {
-      if (filename.toLowerCase().substr(-ext.length) === ext) {
-        transform = _this.transforms[ext]
-        break
-      }
-    }
-
-    if (transform) {
-      code = transform(code, { filename: filename, relFile: inFile })
-    }
-
-    if (!output) {
-      console.log(code)
-    } else {
-      var outFile = path.resolve(output, filename)
+  let inputDir = '.' + path.sep
+  const visitor = relFile => {
+    const inFile = path.resolve(inputDir, relFile)
+    const inCode = fs.readFileSync(inFile, 'utf-8')
+    const outCode = this._transform(inCode, inFile) || inCode
+
+    if (output) {
+      const mode = fs.statSync(inFile).mode
+      const outFile = path.resolve(output, relFile)
       mkdirp.sync(path.dirname(outFile))
-      fs.writeFileSync(outFile, code, 'utf-8')
+      fs.writeFileSync(outFile, outCode)
+      fs.chmodSync(outFile, mode)
+    } else {
+      console.log(outCode)
     }
   }
 
   this._loadAdditionalModules()
 
   try {
-    var stats = fs.lstatSync(input)
+    const stats = fs.lstatSync(input)
     if (stats.isDirectory()) {
       inputDir = input
-      this.walkAllFiles(input, visitor)
+
+      const filesToInstrument = this.exclude.globSync(input)
+
+      if (this.config.completeCopy && output) {
+        const globOptions = { dot: true, nodir: true, ignore: ['**/.git', '**/.git/**', path.join(output, '**')] }
+        glob.sync(path.resolve(input, '**'), globOptions)
+          .forEach(src => cpFile.sync(src, path.join(output, path.relative(input, src))))
+      }
+      filesToInstrument.forEach(visitor)
     } else {
       visitor(input)
     }
@@ -241,34 +213,19 @@ NYC.prototype.instrumentAllFiles = function (input, output, cb) {
   cb()
 }
 
-NYC.prototype.walkAllFiles = function (dir, visitor) {
-  var pattern = null
-  if (this.extensions.length === 1) {
-    pattern = '**/*' + this.extensions[0]
-  } else {
-    pattern = '**/*{' + this.extensions.join() + '}'
-  }
+NYC.prototype._transform = function (code, filename) {
+  const extname = path.extname(filename).toLowerCase()
+  const transform = this.transforms[extname] || (() => null)
 
-  glob.sync(pattern, { cwd: dir, nodir: true, ignore: this.exclude.exclude }).forEach(function (filename) {
-    visitor(filename)
-  })
+  return transform(code, { filename })
 }
 
-NYC.prototype._maybeInstrumentSource = function (code, filename, relFile) {
-  var instrument = this.exclude.shouldInstrument(filename, relFile)
-  if (!instrument) {
+NYC.prototype._maybeInstrumentSource = function (code, filename) {
+  if (!this.exclude.shouldInstrument(filename)) {
     return null
   }
 
-  var ext, transform
-  for (ext in this.transforms) {
-    if (filename.toLowerCase().substr(-ext.length) === ext) {
-      transform = this.transforms[ext]
-      break
-    }
-  }
-
-  return transform ? transform(code, { filename: filename, relFile: relFile }) : null
+  return this._transform(code, filename)
 }
 
 NYC.prototype._transformFactory = function (cacheDir) {
@@ -302,16 +259,14 @@ NYC.prototype._transformFactory = function (cacheDir) {
 }
 
 NYC.prototype._handleJs = function (code, options) {
-  var filename = options.filename
-  var relFile = path.relative(this.cwd, filename)
   // ensure the path has correct casing (see istanbuljs/nyc#269 and nodejs/node#6624)
-  filename = path.resolve(this.cwd, relFile)
-  return this._maybeInstrumentSource(code, filename, relFile) || code
+  const filename = path.resolve(this.cwd, options.filename)
+  return this._maybeInstrumentSource(code, filename) || code
 }
 
 NYC.prototype._addHook = function (type) {
-  var handleJs = this._handleJs.bind(this)
-  var dummyMatcher = function () { return true } // we do all processing in transformer
+  const handleJs = this._handleJs.bind(this)
+  const dummyMatcher = () => true // we do all processing in transformer
   libHook['hook' + type](dummyMatcher, handleJs, { extensions: this.extensions })
 }
 
@@ -341,9 +296,7 @@ NYC.prototype.createTempDirectory = function () {
   mkdirp.sync(this.tempDirectory())
   if (this.cache) mkdirp.sync(this.cacheDirectory)
 
-  if (this._showProcessTree) {
-    mkdirp.sync(this.processInfoDirectory())
-  }
+  mkdirp.sync(this.processInfoDirectory())
 }
 
 NYC.prototype.reset = function () {
@@ -352,16 +305,15 @@ NYC.prototype.reset = function () {
 }
 
 NYC.prototype._wrapExit = function () {
-  var _this = this
-
   // we always want to write coverage
   // regardless of how the process exits.
-  onExit(function () {
-    _this.writeCoverageFile()
+  onExit(() => {
+    this.writeCoverageFile()
   }, { alwaysLast: true })
 }
 
 NYC.prototype.wrap = function (bin) {
+  process.env.NYC_PROCESS_ID = this.processInfo.uuid
   this._addRequireHooks()
   this._wrapExit()
   this._loadAdditionalModules()
@@ -391,7 +343,7 @@ NYC.prototype.writeCoverageFile = function () {
     coverage = this.sourceMaps.remapCoverage(coverage)
   }
 
-  var id = this.generateUniqueID()
+  var id = this.processInfo.uuid
   var coverageFilename = path.resolve(this.tempDirectory(), id + '.json')
 
   fs.writeFileSync(
@@ -400,11 +352,8 @@ NYC.prototype.writeCoverageFile = function () {
     'utf-8'
   )
 
-  if (!this._showProcessTree) {
-    return
-  }
-
   this.processInfo.coverageFilename = coverageFilename
+  this.processInfo.files = Object.keys(coverage)
 
   fs.writeFileSync(
     path.resolve(this.processInfoDirectory(), id + '.json'),
@@ -421,22 +370,22 @@ function coverageFinder () {
 }
 
 NYC.prototype.getCoverageMapFromAllCoverageFiles = function (baseDirectory) {
-  var _this = this
-  var map = libCoverage.createCoverageMap({})
+  const map = libCoverage.createCoverageMap({})
 
   this.eachReport(undefined, (report) => {
     map.merge(report)
   }, baseDirectory)
+
+  map.data = this.sourceMaps.remapCoverage(map.data)
+
   // depending on whether source-code is pre-instrumented
   // or instrumented using a JIT plugin like @babel/require
   // you may opt to exclude files after applying
   // source-map remapping logic.
   if (this.config.excludeAfterRemap) {
-    map.filter(function (filename) {
-      return _this.exclude.shouldInstrument(filename)
-    })
+    map.filter(filename => this.exclude.shouldInstrument(filename))
   }
-  map.data = this.sourceMaps.remapCoverage(map.data)
+
   return map
 }
 
@@ -462,6 +411,80 @@ NYC.prototype.report = function () {
   }
 }
 
+// XXX(@isaacs) Index generation should move to istanbul-lib-processinfo
+NYC.prototype.writeProcessIndex = function () {
+  const dir = this.processInfoDirectory()
+  const pidToUid = new Map()
+  const infoByUid = new Map()
+  const eidToUid = new Map()
+  const infos = fs.readdirSync(dir).filter(f => f !== 'index.json').map(f => {
+    try {
+      const info = JSON.parse(fs.readFileSync(path.resolve(dir, f), 'utf-8'))
+      info.children = []
+      pidToUid.set(info.uuid, info.pid)
+      pidToUid.set(info.pid, info.uuid)
+      infoByUid.set(info.uuid, info)
+      if (info.externalId) {
+        eidToUid.set(info.externalId, info.uuid)
+      }
+      return info
+    } catch (er) {
+      return null
+    }
+  }).filter(Boolean)
+
+  // create all the parent-child links and write back the updated info
+  infos.forEach(info => {
+    if (info.parent) {
+      const parentInfo = infoByUid.get(info.parent)
+      if (parentInfo.children.indexOf(info.uuid) === -1) {
+        parentInfo.children.push(info.uuid)
+      }
+    }
+  })
+
+  // figure out which files were touched by each process.
+  const files = infos.reduce((files, info) => {
+    info.files.forEach(f => {
+      files[f] = files[f] || []
+      files[f].push(info.uuid)
+    })
+    return files
+  }, {})
+
+  // build the actual index!
+  const index = infos.reduce((index, info) => {
+    index.processes[info.uuid] = {}
+    index.processes[info.uuid].parent = info.parent
+    if (info.externalId) {
+      if (index.externalIds[info.externalId]) {
+        throw new Error(`External ID ${info.externalId} used by multiple processes`)
+      }
+      index.processes[info.uuid].externalId = info.externalId
+      index.externalIds[info.externalId] = {
+        root: info.uuid,
+        children: info.children
+      }
+    }
+    index.processes[info.uuid].children = Array.from(info.children)
+    return index
+  }, { processes: {}, files: files, externalIds: {} })
+
+  // flatten the descendant sets of all the externalId procs
+  Object.keys(index.externalIds).forEach(eid => {
+    const { children } = index.externalIds[eid]
+    // push the next generation onto the list so we accumulate them all
+    for (let i = 0; i < children.length; i++) {
+      const nextGen = index.processes[children[i]].children
+      if (nextGen && nextGen.length) {
+        children.push(...nextGen.filter(uuid => children.indexOf(uuid) === -1))
+      }
+    }
+  })
+
+  fs.writeFileSync(path.resolve(dir, 'index.json'), JSON.stringify(index))
+}
+
 NYC.prototype.showProcessTree = function () {
   var processTree = ProcessInfo.buildProcessTree(this._loadProcessInfos())
 
@@ -481,9 +504,6 @@ NYC.prototype.checkCoverage = function (thresholds, perFile) {
     // ERROR: Coverage for lines (90.12%) does not meet global threshold (120%)
     nyc._checkCoverage(map.getCoverageSummary(), thresholds)
   }
-
-  // process.exitCode was not implemented until v0.11.8.
-  if (/^v0\.(1[0-1]\.|[0-9]\.)/.test(process.version) && process.exitCode !== 0) process.exit(process.exitCode)
 }
 
 NYC.prototype._checkCoverage = function (summary, thresholds, file) {
@@ -501,19 +521,25 @@ NYC.prototype._checkCoverage = function (summary, thresholds, file) {
 }
 
 NYC.prototype._loadProcessInfos = function () {
-  var _this = this
-  var files = fs.readdirSync(this.processInfoDirectory())
-
-  return files.map(function (f) {
+  return fs.readdirSync(this.processInfoDirectory()).map(f => {
+    let data
     try {
-      return new ProcessInfo(JSON.parse(fs.readFileSync(
-        path.resolve(_this.processInfoDirectory(), f),
+      data = JSON.parse(fs.readFileSync(
+        path.resolve(this.processInfoDirectory(), f),
         'utf-8'
-      )))
+      ))
     } catch (e) { // handle corrupt JSON output.
-      return {}
+      return null
     }
-  })
+    if (f !== 'index.json') {
+      data.nodes = []
+      data = new ProcessInfo(data)
+    }
+    return { file: path.basename(f, '.json'), data: data }
+  }).filter(Boolean).reduce((infos, info) => {
+    infos[info.file] = info.data
+    return infos
+  }, {})
 }
 
 NYC.prototype.eachReport = function (filenames, iterator, baseDirectory) {

package/lib/commands/check-coverage.js

@@ -1,9 +1,5 @@
-var NYC
-try {
-  NYC = require('../../index.covered.js')
-} catch (e) {
-  NYC = require('../../index.js')
-}
+const testExclude = require('test-exclude')
+const NYC = require('../../index.js')
 
 exports.command = 'check-coverage'
 
@@ -11,6 +7,30 @@ exports.describe = 'check whether coverage is within thresholds provided'
 
 exports.builder = function (yargs) {
   yargs
+    .option('exclude', {
+      alias: 'x',
+      default: testExclude.defaultExclude,
+      describe: 'a list of specific files and directories that should be excluded from coverage, glob patterns are supported, node_modules is always excluded',
+      global: false
+    })
+    .option('exclude-node-modules', {
+      default: true,
+      type: 'boolean',
+      describe: 'whether or not to exclude all node_module folders (i.e. **/node_modules/**) by default',
+      global: false
+    })
+    .option('exclude-after-remap', {
+      default: true,
+      type: 'boolean',
+      description: 'should exclude logic be performed after the source-map remaps filenames?',
+      global: false
+    })
+    .option('include', {
+      alias: 'n',
+      default: [],
+      describe: 'a list of specific files that should be covered, glob patterns are supported',
+      global: false
+    })
     .option('branches', {
       default: 0,
       description: 'what % of branches must be covered?'

package/lib/commands/instrument.js

@@ -1,9 +1,7 @@
-var NYC
-try {
-  NYC = require('../../index.covered.js')
-} catch (e) {
-  NYC = require('../../index.js')
-}
+const NYC = require('../../index.js')
+const path = require('path')
+const rimraf = require('rimraf')
+const testExclude = require('test-exclude')
 
 exports.command = 'instrument <input> [output]'
 
@@ -51,32 +49,74 @@ exports.builder = function (yargs) {
       type: 'boolean',
       description: 'should nyc exit when an instrumentation failure occurs?'
     })
+    .option('include', {
+      alias: 'n',
+      default: [],
+      describe: 'a list of specific files and directories that should be instrumented, glob patterns are supported'
+    })
+    .option('exclude', {
+      alias: 'x',
+      default: testExclude.defaultExclude,
+      describe: 'a list of specific files and directories that should not be instrumented, glob patterns are supported'
+    })
+    .option('exclude-node-modules', {
+      default: true,
+      type: 'boolean',
+      describe: 'whether or not to exclude all node_module folders (i.e. **/node_modules/**) by default',
+      global: false
+    })
+    .option('es-modules', {
+      default: true,
+      type: 'boolean',
+      description: 'tell the instrumenter to treat files as ES Modules'
+    })
+    .option('delete', {
+      describe: 'should the output folder be deleted before instrumenting files?',
+      default: false,
+      type: 'boolean'
+    })
+    .option('complete-copy', {
+      describe: 'should nyc copy all files from input to output as well as instrumented files?',
+      default: false,
+      type: 'boolean'
+    })
     .example('$0 instrument ./lib ./output', 'instrument all .js files in ./lib with coverage and output in ./output')
 }
 
 exports.handler = function (argv) {
-  // if instrument is set to false,
-  // enable a noop instrumenter.
-  if (!argv.instrument) argv.instrumenter = './lib/instrumenters/noop'
-  else argv.instrumenter = './lib/instrumenters/istanbul'
+  if (argv.output && (path.resolve(argv.cwd, argv.input) === path.resolve(argv.cwd, argv.output))) {
+    console.error(`nyc instrument failed: cannot instrument files in place, <input> must differ from <output>`)
+    process.exitCode = 1
+    return
+  }
 
-  var nyc = new NYC({
-    instrumenter: argv.instrumenter,
-    sourceMap: argv.sourceMap,
-    produceSourceMap: argv.produceSourceMap,
-    extension: argv.extension,
-    require: argv.require,
-    compact: argv.compact,
-    preserveComments: argv.preserveComments,
-    exitOnError: argv.exitOnError
-  })
+  if (path.relative(argv.cwd, path.resolve(argv.cwd, argv.input)).startsWith('..')) {
+    console.error(`nyc instrument failed: cannot instrument files outside of project root directory`)
+    process.exitCode = 1
+    return
+  }
 
-  nyc.instrumentAllFiles(argv.input, argv.output, function (err) {
+  if (argv.delete && argv.output && argv.output.length !== 0) {
+    const relPath = path.relative(process.cwd(), path.resolve(argv.output))
+    if (relPath !== '' && !relPath.startsWith('..')) {
+      rimraf.sync(argv.output)
+    } else {
+      console.error(`nyc instrument failed: attempt to delete '${process.cwd()}' or containing directory.`)
+      process.exit(1)
+    }
+  }
+
+  // If instrument is set to false enable a noop instrumenter.
+  argv.instrumenter = (argv.instrument)
+    ? './lib/instrumenters/istanbul'
+    : './lib/instrumenters/noop'
+
+  const nyc = new NYC(argv)
+
+  nyc.instrumentAllFiles(argv.input, argv.output, err => {
     if (err) {
       console.error(err.message)
-      process.exit(1)
-    } else {
-      process.exit(0)
+      process.exitCode = 1
     }
   })
 }

package/lib/commands/merge.js

@@ -3,12 +3,7 @@ const fs = require('fs')
 const path = require('path')
 const makeDir = require('make-dir')
 
-var NYC
-try {
-  NYC = require('../../index.covered.js')
-} catch (e) {
-  NYC = require('../../index.js')
-}
+const NYC = require('../../index.js')
 
 exports.command = 'merge <input-directory> [output-file]'