nyc 3.0.1 → 3.2.2

package/.npmignore

@@ -1,3 +1,5 @@
 .nyc_output
 coverage
 node_modules
+!node_modules/spawn-wrap
+!node_modules/foreground-child

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 ## Change Log
 
+### v3.2.2 (2015/09/11 22:02 -07:00)
+
+- [#47](https://github.com/bcoe/nyc/pull/47) make the default exclude rules work on Windows (@bcoe)
+- [#45](https://github.com/bcoe/nyc/pull/45) pull in patched versions of spawn-wrap and foreground-child, which support Windows (@bcoe)
+- [#44](https://github.com/bcoe/nyc/pull/44) Adds --all option which adds 0% coverage reports for all files in project, regardless of whether code touches them (@ronkorving)
+
+### v3.1.0 (2015/08/02 19:04 +00:00)
+
+- [#38](https://github.com/bcoe/nyc/pull/38) fixes for windows spawning (@rmg)
+
 ### v3.0.1 (2015/07/25 20:51 +00:00)
 - [#33](https://github.com/bcoe/nyc/pull/33) spawn istanbul in a way that is less likely to break npm@3.x (@bcoe)
 

package/README.md

@@ -95,6 +95,11 @@ adding the following configuration:
 }}
 ```
 
+## Include Reports For Files That Are Not Required
+
+By default nyc does not collect coverage for files that have not
+been required, run nyc with the flag `--all` to enable this.
+
 ## Configuring Istanbul
 
 Behind the scenes nyc uses [istanbul](https://www.npmjs.com/package/istanbul). You

package/bin/nyc.js

@@ -66,6 +66,12 @@ if (process.env.NYC_CWD) {
       type: 'boolean',
       describe: "don't output a report after tests finish running"
     })
+    .option('a', {
+      alias: 'all',
+      default: false,
+      type: 'boolean',
+      describe: 'whether or not to instrument all files of the project (not just the ones touched by your test suite)'
+    })
     .help('h')
     .alias('h', 'help')
     .version(require('../package.json').version)
@@ -81,8 +87,9 @@ if (process.env.NYC_CWD) {
     report(argv)
   } else if (~argv._.indexOf('check-coverage')) {
     foreground(
-      require.resolve('istanbul/lib/cli'),
+      process.execPath,
       [
+        require.resolve('istanbul/lib/cli'),
         'check-coverage',
         '--lines=' + argv.lines,
         '--functions=' + argv.functions,
@@ -96,6 +103,8 @@ if (process.env.NYC_CWD) {
     var nyc = (new NYC())
     nyc.cleanup()
 
+    if (argv.all) nyc.addAllFiles()
+
     sw([__filename], {
       NYC_CWD: process.cwd()
     })

package/index.js

@@ -1,6 +1,7 @@
 /* global __coverage__ */
 var _ = require('lodash')
 var fs = require('fs')
+var glob = require('glob')
 var mkdirp = require('mkdirp')
 var path = require('path')
 var rimraf = require('rimraf')
@@ -24,15 +25,14 @@ function NYC (opts) {
   var config = require(path.resolve(this.cwd, './package.json')).config || {}
   config = config.nyc || {}
 
-  this.exclude = config.exclude || ['node_modules\/', 'test\/', 'test\\.js']
+  this.exclude = config.exclude || ['node_modules[\/\\\\]', 'test[\/\\\\]', 'test\\.js']
   if (!Array.isArray(this.exclude)) this.exclude = [this.exclude]
   this.exclude = _.map(this.exclude, function (p) {
     return new RegExp(p)
   })
 
   this.instrumenter = this._createInstrumenter()
-
-  mkdirp.sync(this.tmpDirectory())
+  this._createOutputDirectory()
 }
 
 NYC.prototype._createInstrumenter = function () {
@@ -50,53 +50,75 @@ NYC.prototype._createInstrumenter = function () {
   })
 }
 
-NYC.prototype.cleanup = function () {
-  if (!process.env.NYC_CWD) rimraf.sync(this.tmpDirectory())
+NYC.prototype.addFile = function (filename, returnImmediately) {
+  var instrument = true
+  var relFile = path.relative(this.cwd, filename)
+
+  // only instrument a file if it's not on the exclude list.
+  for (var i = 0, exclude; (exclude = this.exclude[i]) !== undefined; i++) {
+    if (exclude.test(relFile)) {
+      if (returnImmediately) return {}
+      instrument = false
+      break
+    }
+  }
+
+  var content = stripBom(fs.readFileSync(filename, 'utf8'))
+
+  if (instrument) {
+    content = this.instrumenter.instrumentSync(content, './' + relFile)
+  }
+
+  return {
+    instrument: instrument,
+    content: content,
+    relFile: relFile
+  }
 }
 
-NYC.prototype._wrapRequire = function () {
+NYC.prototype.addAllFiles = function () {
   var _this = this
 
-  // any JS you require should get coverage added.
-  require.extensions['.js'] = function (module, filename) {
-    var instrument = true
-    var content = fs.readFileSync(filename, 'utf8')
+  this._createOutputDirectory()
 
-    // only instrument a file if it's not on the exclude list.
-    var relFile = path.relative(_this.cwd, filename)
-    for (var i = 0, exclude; (exclude = _this.exclude[i]) !== undefined; i++) {
-      if (exclude.test(relFile)) instrument = false
-    }
-
-    if (instrument) {
-      content = _this.instrumenter.instrumentSync(
-        content,
-        './' + relFile
+  glob.sync('**/*.js', {nodir: true}).forEach(function (filename) {
+    var obj = _this.addFile(filename, true)
+    if (obj.instrument) {
+      module._compile(
+        _this.instrumenter.getPreamble(obj.content, obj.relFile),
+        filename
       )
     }
+  })
 
-    module._compile(stripBom(content), filename)
+  this.writeCoverageFile()
+}
+
+NYC.prototype._wrapRequire = function () {
+  var _this = this
+
+  // any JS you require should get coverage added.
+  require.extensions['.js'] = function (module, filename) {
+    var obj = _this.addFile(filename)
+    module._compile(obj.content, filename)
   }
 }
 
+NYC.prototype.cleanup = function () {
+  if (!process.env.NYC_CWD) rimraf.sync(this.tmpDirectory())
+}
+
+NYC.prototype._createOutputDirectory = function () {
+  mkdirp.sync(this.tmpDirectory())
+}
+
 NYC.prototype._wrapExit = function () {
   var _this = this
-  var outputCoverage = function () {
-    var coverage = global.__coverage__
-    if (typeof __coverage__ === 'object') coverage = __coverage__
-    if (!coverage) return
-
-    fs.writeFileSync(
-      path.resolve(_this.tmpDirectory(), './', process.pid + '.json'),
-      JSON.stringify(coverage),
-      'utf-8'
-    )
-  }
 
   // we always want to write coverage
   // regardless of how the process exits.
   onExit(function () {
-    outputCoverage()
+    _this.writeCoverageFile()
   }, {alwaysLast: true})
 }
 
@@ -106,6 +128,18 @@ NYC.prototype.wrap = function (bin) {
   return this
 }
 
+NYC.prototype.writeCoverageFile = function () {
+  var coverage = global.__coverage__
+  if (typeof __coverage__ === 'object') coverage = __coverage__
+  if (!coverage) return
+
+  fs.writeFileSync(
+    path.resolve(this.tmpDirectory(), './', process.pid + '.json'),
+    JSON.stringify(coverage),
+    'utf-8'
+  )
+}
+
 NYC.prototype.report = function (cb, _collector, _reporter) {
   cb = cb || function () {}
 
@@ -145,8 +179,17 @@ NYC.prototype.tmpDirectory = function () {
 
 NYC.prototype.mungeArgs = function (yargv) {
   var argv = process.argv.slice(1)
+  argv = argv.slice(argv.indexOf(yargv._[0]))
+  if (!/^(node|iojs)$/.test(argv[0]) &&
+      process.platform === 'win32' &&
+      (/\.js$/.test(argv[0]) ||
+        (!/\.(cmd|exe)$/.test(argv[0]) &&
+        !fs.existsSync(argv[0] + '.cmd') &&
+        !fs.existsSync(argv[0] + '.exe')))) {
+    argv.unshift(process.execPath)
+  }
 
-  return argv.slice(argv.indexOf(yargv._[0]))
+  return argv
 }
 
 module.exports = NYC

package/node_modules/foreground-child/.npmignore

@@ -0,0 +1,3 @@
+node_modules
+.DS_Store
+.nyc_output

package/node_modules/foreground-child/.travis.yml

@@ -0,0 +1,6 @@
+sudo: false
+language: node_js
+node_js:
+  - '0.12'
+  - '0.10'
+  - iojs

package/node_modules/foreground-child/LICENSE

@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) Isaac Z. Schlueter and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/node_modules/foreground-child/README.md

@@ -0,0 +1,33 @@
+# foreground-child
+
+[![Build Status](https://travis-ci.org/isaacs/foreground-child.png)](https://travis-ci.org/isaacs/foreground-child)
+
+Run a child as if it's the foreground process.  Give it stdio.  Exit
+when it exits.
+
+Mostly this module is here to support some use cases around wrapping
+child processes for test coverage and such.
+
+## USAGE
+
+```js
+var foreground = require('foreground-child')
+
+// cats out this file
+var child = foreground('cat', [__filename])
+
+// At this point, it's best to just do nothing else.
+// return or whatever.
+// If the child gets a signal, or just exits, then this
+// parent process will exit in the same way.
+```
+
+A callback can optionally be provided, if you want to perform an action
+before your foreground-child exits:
+
+```js
+var child = foreground('cat', [__filename], function (done) {
+  // perform an action.
+  return done()
+})
+```

package/node_modules/foreground-child/index.js

@@ -0,0 +1,54 @@
+var signalExit = require('signal-exit')
+var spawn = require('win-spawn')
+
+module.exports = function (program, args, cb) {
+  var arrayIndex = arguments.length
+
+  if (typeof args === 'function') {
+    cb = args
+    args = undefined
+  } else {
+    cb = Array.prototype.slice.call(arguments).filter(function (arg, i) {
+      if (typeof arg === 'function') {
+        arrayIndex = i
+        return true
+      }
+    })[0]
+  }
+
+  cb = cb || function (done) {
+    return done()
+  }
+
+  if (Array.isArray(program)) {
+    args = program.slice(1)
+    program = program[0]
+  } else if (!Array.isArray(args)) {
+    args = [].slice.call(arguments, 1, arrayIndex)
+  }
+
+  var child = spawn(program, args, { stdio: 'inherit' })
+
+  var childExited = false
+  signalExit(function (code, signal) {
+    child.kill(signal || 'SIGHUP')
+  })
+
+  child.on('close', function (code, signal) {
+    cb(function () {
+      childExited = true
+      if (signal) {
+        // If there is nothing else keeping the event loop alive,
+        // then there's a race between a graceful exit and getting
+        // the signal to this process.  Put this timeout here to
+        // make sure we're still alive to get the signal, and thus
+        // exit with the intended signal code.
+        setTimeout(function () {}, 200)
+        process.kill(process.pid, signal)
+      } else
+        process.exit(code)
+    })
+  })
+
+  return child
+}

package/node_modules/foreground-child/node_modules/win-spawn/.npmignore

@@ -0,0 +1,15 @@
+lib-cov
+*.seed
+*.log
+*.csv
+*.dat
+*.out
+*.pid
+*.gz
+
+pids
+logs
+results
+
+node_modules
+npm-debug.log

package/node_modules/foreground-child/node_modules/win-spawn/README.md

@@ -0,0 +1,41 @@
+# win-spawn
+
+  Spawn for node.js but in a way that works regardless of which OS you're using.  Use this if you want to use spawn with a JavaScript file.  It works by explicitly invoking node on windows.  It also shims support for environment variable setting by attempting to parse the command with a regex.  Since all modification is wrapped in `if (os === 'Windows_NT')` it can be safely used on non-windows systems and will not break anything.
+
+## Installation
+
+  $ npm install win-spawn
+
+## Usage
+
+### Command Line
+
+  All the following will work exactly as if the 'win-spawn ' prefix was ommitted when on unix.
+
+    $ win-spawn foo
+    $ win-spawn ./bin/foo
+    $ win-spawn NODE_PATH=./lib foo
+    $ win-spawn NODE_PATH=./lib foo arg1 arg2
+
+  You can also transform all the line endings in a directory from `\r\n` to `\n` just by running:
+
+    $ win-line-endings
+
+  You can preview the changes by running:
+
+    $ win-line-endings -p
+
+  It will ignore `node_modules` and `.git` by default, but is not clever enough to recognise binary files yet.
+
+### API
+
+This will just pass through to `child_process.spawn` on unix systems, but will correctly parse the arguments on windows.
+
+```javascript
+spawn('foo', [], {stdio: 'inherit'});
+spawn('./bin/foo', [], {stdio: 'inherit'});
+spawn('NODE_PATH=./lib foo', [], {stdio: 'inherit'});
+spawn('NODE_PATH=./lib foo', [arg1, arg2], {stdio: 'inherit'});
+```
+
+![viewcount](https://viewcount.jepso.com/count/ForbesLindesay/win-spawn.png)

package/node_modules/foreground-child/node_modules/win-spawn/bin/win-spawn

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+
+var spawn = require('../index.js');
+
+var args = process.argv.slice(2);
+var cmd = '';
+while (/^[A-Z_]+\=[^ \=]+$/.test(args[0])) {
+  cmd += args.shift() + ' ';
+}
+cmd += args.shift();
+
+spawn(cmd, args, { stdio: 'inherit' });

package/node_modules/foreground-child/node_modules/win-spawn/index.js

@@ -0,0 +1,64 @@
+var cSpawn = require('child_process').spawn;
+var os = require('os').type();
+
+exports = module.exports = spawn;
+function spawn(command, args, options) {
+  if (os === 'Windows_NT') {
+    command = command.replace(/\//g, '\\');
+    
+    if (command === 'rm') {
+      command = 'rmdir';
+      if (args[0] === '-rf' || args[0] == '-fr') {
+        args[0] = '/q';
+        args.unshift('/s');
+      }
+      if (args[0] === '-f') {
+        args[0] = '/q';
+      }
+      if (args[0] === '-r') {
+        args[0] = '/s';
+      }
+    }
+    args = args || [];
+    options = options || {};
+    var match, matchA;
+    if (matchA = /((?:[A-Z_]+\=[^ \=]+ )+)?([^\r\n]+)/.exec(command)) {
+      try {
+        var file = require('fs').readFileSync(matchA[2], 'utf8');
+        if (match = /\#\!\/usr\/bin\/env ([^\r\n]+)/.exec(file)) {
+          args.unshift(matchA[2]);
+          command = (matchA[1] || '') + match[1];
+        }
+      } catch (ex) { }
+    }
+
+    if (match = /((?:[A-Z_]+\=[^ \=]+ )+)([^\r\n]+)/.exec(command)) {
+      command = match[2];
+
+      options.env = options.env || shallowClone(process.env);
+
+      var env = match[1].split(' ');
+      env.forEach(function (v) {
+        v = v.split('=');
+        if (v.length === 2) {
+          options.env[v[0]] = v[1];
+        }
+      });
+    }
+
+    args.unshift(command);
+    args.unshift('/c');
+    args.unshift('/d');
+    command = 'cmd';
+  }
+  return cSpawn(command, args, options);
+}
+
+function shallowClone(obj) {
+  var out = {};
+  Object.keys(obj)
+    .forEach(function (key) {
+      out[key] = obj[key];
+    });
+  return out;
+}

package/node_modules/foreground-child/node_modules/win-spawn/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "win-spawn",
+  "version": "2.0.0",
+  "description": "Spawn for node.js but in a way that works regardless of which OS you're using",
+  "main": "index.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ForbesLindesay/win-spawn.git"
+  },
+  "bin": {
+    "win-spawn": "./bin/win-spawn"
+  },
+  "devDependencies": {
+    "linify": "~1.0.1"
+  },
+  "scripts": {
+    "prepublish": "linify transform bin"
+  },
+  "author": {
+    "name": "ForbesLindesay"
+  },
+  "license": "BSD",
+  "readme": "# win-spawn\n\n  Spawn for node.js but in a way that works regardless of which OS you're using.  Use this if you want to use spawn with a JavaScript file.  It works by explicitly invoking node on windows.  It also shims support for environment variable setting by attempting to parse the command with a regex.  Since all modification is wrapped in `if (os === 'Windows_NT')` it can be safely used on non-windows systems and will not break anything.\n\n## Installation\n\n  $ npm install win-spawn\n\n## Usage\n\n### Command Line\n\n  All the following will work exactly as if the 'win-spawn ' prefix was ommitted when on unix.\n\n    $ win-spawn foo\n    $ win-spawn ./bin/foo\n    $ win-spawn NODE_PATH=./lib foo\n    $ win-spawn NODE_PATH=./lib foo arg1 arg2\n\n  You can also transform all the line endings in a directory from `\\r\\n` to `\\n` just by running:\n\n    $ win-line-endings\n\n  You can preview the changes by running:\n\n    $ win-line-endings -p\n\n  It will ignore `node_modules` and `.git` by default, but is not clever enough to recognise binary files yet.\n\n### API\n\nThis will just pass through to `child_process.spawn` on unix systems, but will correctly parse the arguments on windows.\n\n```javascript\nspawn('foo', [], {stdio: 'inherit'});\nspawn('./bin/foo', [], {stdio: 'inherit'});\nspawn('NODE_PATH=./lib foo', [], {stdio: 'inherit'});\nspawn('NODE_PATH=./lib foo', [arg1, arg2], {stdio: 'inherit'});\n```\n\n![viewcount](https://viewcount.jepso.com/count/ForbesLindesay/win-spawn.png)\n",
+  "readmeFilename": "README.md",
+  "_id": "win-spawn@2.0.0",
+  "dist": {
+    "shasum": "397a29130ec98d0aa0bc86baa4621393effd0b07",
+    "tarball": "http://registry.npmjs.org/win-spawn/-/win-spawn-2.0.0.tgz"
+  },
+  "_from": "win-spawn@>=2.0.0 <3.0.0",
+  "_npmVersion": "1.2.10",
+  "_npmUser": {
+    "name": "forbeslindesay",
+    "email": "forbes@lindesay.co.uk"
+  },
+  "maintainers": [
+    {
+      "name": "forbeslindesay",
+      "email": "forbes@lindesay.co.uk"
+    }
+  ],
+  "directories": {},
+  "_shasum": "397a29130ec98d0aa0bc86baa4621393effd0b07",
+  "_resolved": "https://registry.npmjs.org/win-spawn/-/win-spawn-2.0.0.tgz"
+}

package/node_modules/foreground-child/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "foreground-child",
+  "version": "1.3.0",
+  "description": "Run a child as if it's the foreground process.  Give it stdio.  Exit when it exits.",
+  "main": "index.js",
+  "directories": {
+    "test": "test"
+  },
+  "dependencies": {
+    "signal-exit": "^2.0.0",
+    "win-spawn": "^2.0.0"
+  },
+  "devDependencies": {
+    "tap": "^1.2.1"
+  },
+  "scripts": {
+    "test": "tap --coverage test/*.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/isaacs/foreground-child.git"
+  },
+  "author": {
+    "name": "Isaac Z. Schlueter",
+    "email": "i@izs.me",
+    "url": "http://blog.izs.me/"
+  },
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/isaacs/foreground-child/issues"
+  },
+  "homepage": "https://github.com/isaacs/foreground-child#readme",
+  "gitHead": "ad7ba1d4a84e8b199cbfb5d30e01e586390978cc",
+  "readme": "# foreground-child\n\n[![Build Status](https://travis-ci.org/isaacs/foreground-child.png)](https://travis-ci.org/isaacs/foreground-child)\n\nRun a child as if it's the foreground process.  Give it stdio.  Exit\nwhen it exits.\n\nMostly this module is here to support some use cases around wrapping\nchild processes for test coverage and such.\n\n## USAGE\n\n```js\nvar foreground = require('foreground-child')\n\n// cats out this file\nvar child = foreground('cat', [__filename])\n\n// At this point, it's best to just do nothing else.\n// return or whatever.\n// If the child gets a signal, or just exits, then this\n// parent process will exit in the same way.\n```\n\nA callback can optionally be provided, if you want to perform an action\nbefore your foreground-child exits:\n\n```js\nvar child = foreground('cat', [__filename], function (done) {\n  // perform an action.\n  return done()\n})\n```\n",
+  "readmeFilename": "README.md",
+  "_id": "foreground-child@1.3.0",
+  "_shasum": "709eb362a23a7befd3ba349fddfc7168957831d5",
+  "_from": "git+https://github.com/bcoe/foreground-child.git#win-spawn",
+  "_resolved": "git+https://github.com/bcoe/foreground-child.git#ad7ba1d4a84e8b199cbfb5d30e01e586390978cc"
+}