nyc 3.0.1 → 3.2.2

package/node_modules/spawn-wrap/shim.js

@@ -0,0 +1,139 @@
+// This module should *only* be loaded as a main script
+// by child processes wrapped by spawn-wrap.  It sets up
+// argv to include the injected argv (including the user's
+// wrapper script) and any environment variables specified.
+//
+// If any argv were passed in (ie, if it's used to force
+// a wrapper script, and not just ensure that an env is kept
+// around through all the child procs), then we also set up
+// a require('spawn-wrap').runMain() function that will strip
+// off the injected arguments and run the main file.
+
+if (module !== require.main) {
+  throw new Error('spawn-wrap: cli wrapper invoked as non-main script')
+}
+
+// require('fs').createWriteStream('/dev/tty').write('WRAP ' + process.argv.slice(2).join(' ') + '\n')
+var Module = require('module')
+var assert = require('assert')
+var path = require('path')
+var node = process.execPath
+
+var settings = require('./settings.json')
+var foregroundChild = require(settings.deps.foregroundChild)
+var argv = settings.argv
+var nargs = argv.length
+var env = settings.env
+
+for (var key in env) {
+  process.env[key] = env[key]
+}
+
+var needExecArgv = settings.execArgv || []
+
+// If the user added their OWN wrapper pre-load script, then
+// this will pop that off of the argv, and load the "real" main
+function runMain () {
+  process.argv.splice(1, nargs)
+  process.argv[1] = path.resolve(process.argv[1])
+  Module.runMain()
+}
+
+// Argv coming in looks like:
+// bin shim execArgv main argv
+//
+// Turn it into:
+// bin settings.execArgv execArgv settings.argv main argv
+//
+// If we don't have a main script, then just run with the necessary
+// execArgv
+var hasMain = false
+for (var a = 2; !hasMain && a < process.argv.length; a++) {
+  switch (process.argv[a]) {
+    case '-i':
+    case '--interactive':
+    case '--eval':
+    case '-e':
+    case '-pe':
+      hasMain = false
+      a = process.argv.length
+      continue
+
+    case '-r':
+    case '--require':
+      a += 1
+      continue
+
+    default:
+      if (process.argv[a].match(/^-/)) {
+        continue
+      } else {
+        hasMain = a
+        a = process.argv.length
+        break
+      }
+  }
+}
+
+if (hasMain > 2) {
+  // if the main file is above #2, then it means that there
+  // was a --exec_arg *before* it.  This means that we need
+  // to slice everything from 2 to hasMain, and pass that
+  // directly to node.  This also splices out the user-supplied
+  // execArgv from the argv.
+  var addExecArgv = process.argv.splice(2, hasMain - 2)
+  needExecArgv.push.apply(needExecArgv, addExecArgv)
+}
+
+if (!hasMain) {
+  // we got loaded by mistake for a `node -pe script` or something.
+  var args = process.execArgv.concat(needExecArgv, process.argv.slice(2))
+  foregroundChild(node, args)
+  return
+}
+
+// If there are execArgv, and they're not the same as how this module
+// was executed, then we need to inject those.  This is for stuff like
+// --harmony or --use_strict that needs to be *before* the main
+// module.
+if (needExecArgv.length) {
+  var pexec = process.execArgv
+  if (JSON.stringify(pexec) !== JSON.stringify(needExecArgv)) {
+    var spawn = require('child_process').spawn
+    var sargs = pexec.concat(needExecArgv).concat(process.argv.slice(1))
+    foregroundChild(node, sargs)
+    return
+  }
+}
+
+// At this point, we've verified that we got the correct execArgv,
+// and that we have a main file, and that the main file is sitting at
+// argv[2].  Splice this shim off the list so it looks like the main.
+var spliceArgs = [1, 1].concat(argv)
+process.argv.splice.apply(process.argv, spliceArgs)
+
+// Unwrap the PATH environment var so that we're not mucking
+// with the environment.  It'll get re-added if they spawn anything
+var isWindows = (
+  process.platform === 'win32' ||
+  process.env.OSTYPE === 'cygwin' ||
+  process.env.OSTYPE === 'msys'
+)
+
+if (isWindows) {
+  for (var i in process.env) {
+    if (i.match(/^path$/i)) {
+      process.env[i] = process.env[i].replace(__dirname + ';', '')
+    }
+  }
+} else {
+  process.env.PATH = process.env.PATH.replace(__dirname + ':', '')
+}
+
+var spawnWrap = require(settings.module)
+if (nargs) {
+  spawnWrap.runMain = runMain
+}
+spawnWrap(argv, env, __dirname)
+
+Module.runMain()

package/node_modules/spawn-wrap/t.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+if (process.env.xyz) {
+  console.log('in t.js, xyz=%j', process.env.xyz)
+  console.log('gc is a', typeof gc)
+  console.log('%j', process.argv)
+  console.log('about to run the main file\u001b[32m')
+  require('./index.js').runMain()
+  console.log('\u001b[31mran wrapped main')
+  return
+}
+
+var wrap = require('./index.js')
+
+var unwrap = wrap(['--expose_gc', __filename, ' a $ b '], { xyz: 'ABC' })
+
+console.log('about to run child process')
+console.log('gc is a', typeof gc)
+var cp = require('child_process')
+var child = cp.exec(process.execPath + ' $(which tap ) -h', { env: { foo: 'asdf', PATH:process.env.PATH } }, function (er, out, err) {
+  console.error('returned')
+  console.error('error = ', er)
+  console.error('outlen=', out.length)
+  console.error('\u001b[31m' + out + '\u001b[m')
+  console.error('errlen=', err.length)
+  process.stderr.write(err)
+})

package/node_modules/spawn-wrap/test/basic.js

@@ -0,0 +1,139 @@
+var sw = require('../')
+var onExit = require('signal-exit')
+
+var cp = require('child_process')
+var isWindows = require('../lib/is-windows')()
+var spawn = require('win-spawn')
+var fixture = require.resolve('./fixtures/script.js')
+
+if (process.argv[2] === 'parent') {
+  // hang up once
+  process.once('SIGHUP', function onHup () {
+    console.log('SIGHUP')
+  })
+  // handle sigints forever
+  process.on('SIGINT', function onInt () {
+    console.log('SIGINT')
+  })
+  onExit(function (code, signal) {
+    console.log('EXIT %j', [code, signal])
+  })
+  var argv = process.argv.slice(3).map(function (arg) {
+    if (arg === fixture) {
+      return '{{FIXTURE}}'
+    }
+    return arg
+  })
+  console.log('WRAP %j', process.execArgv.concat(argv))
+  sw.runMain()
+  return
+}
+
+var t = require('tap')
+var unwrap = sw([__filename, 'parent'])
+
+var expect = 'WRAP ["{{FIXTURE}}","xyz"]\n' +
+  '[]\n' +
+  '["xyz"]\n' +
+  'EXIT [0,null]\n'
+
+t.test('spawn execPath', function (t) {
+  var child = spawn(process.execPath, [fixture, 'xyz'])
+
+  var out = ''
+  child.stdout.on('data', function (c) {
+    out += c
+  })
+  child.on('close', function (code, signal) {
+    t.equal(code, 0)
+    t.equal(signal, null)
+    t.equal(out, expect)
+    t.end()
+  })
+})
+
+t.test('exec shebang', function (t) {
+  var child = spawn(fixture, ['xyz'])
+
+  var out = ''
+  child.stdout.on('data', function (c) {
+    out += c
+  })
+  child.on('close', function (code, signal) {
+    t.equal(code, 0)
+    t.equal(signal, null)
+    t.equal(out, expect)
+    t.end()
+  })
+})
+
+if (!isWindows)
+t.test('SIGHUP', function (t) {
+  var child = cp.exec(fixture + ' xyz')
+
+  var out = ''
+  child.stdout.on('data', function (c) {
+    out += c
+    child.kill('SIGHUP')
+  })
+  child.on('close', function (code, signal) {
+    t.equal(code, null)
+    t.equal(signal, 'SIGHUP')
+    t.equal(out, 'WRAP ["{{FIXTURE}}","xyz"]\n' +
+      '[]\n' +
+      '["xyz"]\n' +
+      'SIGHUP\n' +
+      'EXIT [null,"SIGHUP"]\n')
+    t.end()
+  })
+})
+
+if (!isWindows)
+t.test('SIGINT', function (t) {
+  var child = cp.exec(fixture + ' xyz')
+
+  var out = ''
+  child.stdout.on('data', function (c) {
+    out += c
+  })
+  child.stdout.once('data', function () {
+    child.kill('SIGINT')
+  })
+  child.stderr.on('data', function (t) {
+    console.error(t)
+  })
+  child.on('close', function (code, signal) {
+    t.equal(code, 0)
+    t.equal(signal, null)
+    t.equal(out, 'WRAP ["{{FIXTURE}}","xyz"]\n' +
+      '[]\n' +
+      '["xyz"]\n' +
+      'SIGINT\n' +
+      'EXIT [0,null]\n')
+    t.end()
+  })
+})
+
+if (!isWindows)
+t.test('--harmony', function (t) {
+  var node = process.execPath
+  var child = spawn(node, ['--harmony', fixture, 'xyz'])
+  var out = ''
+  child.stdout.on('data', function (c) {
+    out += c
+  })
+  child.on('close', function (code, signal) {
+    t.equal(code, 0)
+    t.equal(signal, null)
+    t.equal(out, 'WRAP ["--harmony","{{FIXTURE}}","xyz"]\n' +
+      '["--harmony"]\n' +
+      '["xyz"]\n' +
+      'EXIT [0,null]\n')
+    t.end()
+  })
+})
+
+t.test('unwrap', function (t) {
+  unwrap()
+  t.end()
+})

package/node_modules/spawn-wrap/test/fixtures/script.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+console.log('%j', process.execArgv)
+console.log('%j', process.argv.slice(2))

package/node_modules/spawn-wrap/test/win-rebase.js

@@ -0,0 +1,20 @@
+var t = require('tap')
+var winRebase = require('../lib/win-rebase')
+
+t.test('it replaces path to node bin', function (t) {
+  var result = winRebase('C:\\Program Files\\nodejs\\node.exe', 'C:\\foo')
+  t.equal(result, 'C:\\foo')
+  t.done()
+})
+
+t.test('it does not replace path if it references an unknown bin', function (t) {
+  var result = winRebase('C:\\Program Files\\nodejs\\banana', 'C:\\foo')
+  t.equal(result, 'C:\\Program Files\\nodejs\\banana')
+  t.done()
+})
+
+t.test('replaces node bin and leaves the script being executed', function (t) {
+  var result = winRebase('C:\\Program Files\\nodejs\\node.exe foo.js', 'C:\\foo')
+  t.equal(result, 'C:\\foo foo.js')
+  t.done()
+})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nyc",
-  "version": "3.0.1",
+  "version": "3.2.2",
   "description": "a code coverage tool that works well with subprocesses.",
   "main": "index.js",
   "scripts": {
@@ -13,7 +13,8 @@
   "config": {
     "nyc": {
       "exclude": [
-        "node_modules/"
+        "node_modules",
+        "bin"
       ]
     }
   },
@@ -36,8 +37,9 @@
   "author": "Ben Coe <ben@npmjs.com>",
   "license": "ISC",
   "dependencies": {
-    "foreground-child": "^1.3.0",
-    "istanbul": "^0.3.16",
+    "foreground-child": "1.3.0",
+    "glob": "^5.0.14",
+    "istanbul": "^0.3.19",
     "lodash": "^3.10.0",
     "mkdirp": "^0.5.0",
     "rimraf": "^2.4.2",
@@ -49,9 +51,13 @@
   "devDependencies": {
     "chai": "^3.0.0",
     "sinon": "^1.15.3",
-    "standard": "^4.5.4",
-    "tap": "^1.3.0"
+    "standard": "^5.2.1",
+    "tap": "^1.3.4"
   },
+  "bundleDependencies": [
+    "foreground-child",
+    "spawn-wrap"
+  ],
   "repository": {
     "type": "git",
     "url": "git@github.com:bcoe/nyc.git"

package/test/fixtures/not-loaded.js

@@ -0,0 +1,2 @@
+var i = 3 + 5
+i++

package/test/nyc-test.js

@@ -15,7 +15,6 @@ describe('nyc', function () {
   var fixtures = path.resolve(__dirname, './fixtures')
 
   describe('cwd', function () {
-
     function afterEach () {
       delete process.env.NYC_CWD
       rimraf.sync(path.resolve(fixtures, './nyc_output'))
@@ -33,7 +32,7 @@ describe('nyc', function () {
 
       var nyc = new NYC()
 
-      nyc.cwd.should.match(/nyc\/test\/fixtures/)
+      nyc.cwd.should.equal(path.resolve(__dirname, './fixtures'))
       afterEach()
     })
   })
@@ -89,6 +88,14 @@ describe('nyc', function () {
     it('writes coverage report when process is killed with SIGINT', function (done) {
       testSignal('sigint', done)
     })
+
+    it('does not output coverage for files that have not been included, by default', function (done) {
+      var reports = _.filter(nyc._loadReports(), function (report) {
+        return report['./test/fixtures/not-loaded.js']
+      })
+      reports.length.should.equal(0)
+      return done()
+    })
   })
 
   describe('report', function () {
@@ -241,7 +248,7 @@ describe('nyc', function () {
       })
       nyc.wrap()
 
-      istanbul.config.loadFile.calledWithMatch('test/fixtures/.istanbul.yml').should.equal(true)
+      istanbul.config.loadFile.calledWithMatch(path.join('test', 'fixtures', '.istanbul.yml')).should.equal(true)
       istanbul.Instrumenter.calledWith({
         coverageVariable: '__coverage__',
         embedSource: false,
@@ -271,4 +278,40 @@ describe('nyc', function () {
       munged.should.eql(['node', 'test/nyc-test.js'])
     })
   })
+
+  describe('addAllFiles', function () {
+    it('outputs an empty coverage report for all files that are not excluded', function (done) {
+      var nyc = (new NYC())
+      nyc.addAllFiles()
+
+      var reports = _.filter(nyc._loadReports(), function (report) {
+        return report['./test/fixtures/not-loaded.js']
+      })
+      var report = reports[0]['./test/fixtures/not-loaded.js']
+
+      reports.length.should.equal(1)
+      report.s['1'].should.equal(0)
+      report.s['2'].should.equal(0)
+      return done()
+    })
+
+    it('tracks coverage appropriately once the file is required', function (done) {
+      var nyc = (new NYC({
+        cwd: process.cwd()
+      })).wrap()
+      require('./fixtures/not-loaded')
+      nyc.writeCoverageFile()
+
+      var reports = _.filter(nyc._loadReports(), function (report) {
+        return report['./test/fixtures/not-loaded.js']
+      })
+      var report = reports[0]['./test/fixtures/not-loaded.js']
+
+      reports.length.should.equal(1)
+      report.s['1'].should.equal(1)
+      report.s['2'].should.equal(1)
+
+      return done()
+    })
+  })
 })