Added support for multiple reporters.

bin/_mocha

@@ -66,10 +66,10 @@ program
   .option('-c, --colors', 'force enabling of colors')
   .option('-C, --no-colors', 'force disabling of colors')
   .option('-G, --growl', 'enable growl notification support')
-  .option('-O, --reporter-options <k=v,k2=v2,...>', 'reporter-specific options')
-  .option('-R, --reporter <name>', 'specify the reporter to use', 'spec')
-  .option('-S, --sort', 'sort test files')
-  .option('-b, --bail', 'bail after first test failure')
+  .option('-O, --reporter-options <k=v,k2=v2,...>', 'reporter-specific options, use name1:{k=v,k2=v2,...},name2:{...} for multiple reporters')
+  .option('-R, --reporter <name>', 'specify the reporter to use, or <name1>,<name2>,... for multiple reporters.', list, ['spec'])
+  .option('-S, --sort', "sort test files")
+  .option('-b, --bail', "bail after first test failure")
   .option('-d, --debug', "enable node's debugger, synonym for node --debug")
   .option('-g, --grep <pattern>', 'only run tests matching <pattern>')
   .option('-f, --fgrep <string>', 'only run tests containing <string>')
@@ -196,16 +196,45 @@ Error.stackTraceLimit = Infinity; // TODO: config
 
 var reporterOptions = {};
 if (program.reporterOptions !== undefined) {
-  program.reporterOptions.split(',').forEach(function (opt) {
-    var L = opt.split('=');
-    if (L.length > 2 || L.length === 0) {
-      throw new Error("invalid reporter option '" + opt + "'");
-    } else if (L.length === 2) {
-      reporterOptions[L[0]] = L[1];
-    } else {
-      reporterOptions[L[0]] = true;
+  var reporterOptionsParser;
+  var multipleReporterFormat = /([^,:]+):{([^}]+)}/g;
+
+  var parseOptions = function (optionsStr) {
+    var options = {};
+    optionsStr.split(',').forEach(function (opt) {
+      var split = opt.split('=');
+      if (split.length > 2 || split.length === 0) {
+        throw new Error("invalid reporter option '" + opt + "'");
+      }
+
+      if (split.length === 2) {
+        options[split[0]] = split[1];
+      } else {
+        options[split[0]] = true;
+      }
+    });
+
+    return options;
+  };
+
+  if (program.reporterOptions.match(multipleReporterFormat)) {
+    // multiple reporter config:
+    //   spec:{a=1,b=2},dot:{c=3,d=4}
+    var match;
+    while ((match = multipleReporterFormat.exec(program.reporterOptions))) {
+      if (match.length !== 3) {
+        throw new Error("invalid multiple reporter options format '" + program.reporterOptions + "'");
+      }
+
+      var reporterName = match[1];
+      var reporterOptionStr = match[2];
+      reporterOptions[reporterName] = parseOptions(reporterOptionStr);
     }
-  });
+  } else {
+    // single reporter config:
+    //   a=1,b=2
+    reporterOptions._default = parseOptions(program.reporterOptions);
+  }
 }
 
 // reporter
@@ -214,16 +243,17 @@ mocha.reporter(program.reporter, reporterOptions);
 
 // load reporter
 
-var Reporter = null;
-try {
-  Reporter = require('../lib/reporters/' + program.reporter);
-} catch (err) {
+program.reporter.forEach(function (reporterName) {
   try {
-    Reporter = require(program.reporter);
-  } catch (err2) {
-    throw new Error('reporter "' + program.reporter + '" does not exist');
+    require('../lib/reporters/' + reporterName);
+  } catch (err) {
+    try {
+      require(reporterName);
+    } catch (err2) {
+      throw new Error('reporter "' + reporterName + '" does not exist');
+    }
   }
-}
+});
 
 // --no-colors
 

lib/mocha.js

@@ -12,7 +12,7 @@
 
 var escapeRe = require('escape-string-regexp');
 var path = require('path');
-var reporters = require('./reporters');
+var builtInReporters = require('./reporters');
 var utils = require('./utils');
 
 /**
@@ -36,7 +36,7 @@ if (!process.browser) {
 
 exports.utils = utils;
 exports.interfaces = require('./interfaces');
-exports.reporters = reporters;
+exports.reporters = builtInReporters;
 exports.Runnable = require('./runnable');
 exports.Context = require('./context');
 exports.Runner = require('./runner');
@@ -129,23 +129,42 @@ Mocha.prototype.addFile = function (file) {
 };
 
 /**
- * Set reporter to `reporter`, defaults to "spec".
+ * Set reporters to `reporters`, defaults to ['spec'].
  *
- * @param {String|Function} reporter name or constructor
- * @param {Object} reporterOptions optional options
+ * @param {String|Function|Array of strings|Array of functions} reporter name as
+ * string, reporter constructor, or array of constructors or reporter names as
+ * strings.
+ * @param {Object} reporterOptions optional options, keyed by reporter name, or
+ * '_default' for options to use when per-name options are not given.
  * @api public
- * @param {string|Function} reporter name or constructor
- * @param {Object} reporterOptions optional options
  */
-Mocha.prototype.reporter = function (reporter, reporterOptions) {
-  if (typeof reporter === 'function') {
-    this._reporter = reporter;
-  } else {
-    reporter = reporter || 'spec';
+Mocha.prototype.reporter = function(reporters, reporterOptions) {
+  // if no reporter is given as input, default to spec reporter
+  reporters = reporters || ['spec'];
+  reporterOptions = reporterOptions || {};
+
+  if (!utils.isArray(reporters)) {
+    if ((typeof reporters === 'string')
+        || (typeof reporters === 'function')) {
+      reporters = [reporters];
+    } else {
+      throw new Error('invalid reporter "' + reporters + '"');
+    }
+  }
+
+  // Load each reporter, only passing the options for that reporter
+  this._reporters = reporters.map(function(reporter) {
+    if (typeof reporter === 'function') {
+      return {
+        fn: reporter,
+        options: reporterOptions
+      };
+    }
+
     var _reporter;
     // Try to load a built-in reporter.
-    if (reporters[reporter]) {
-      _reporter = reporters[reporter];
+    if (builtInReporters[reporter]) {
+      _reporter = builtInReporters[reporter];
     }
     // Try to load reporters from process.cwd() and node_modules
     if (!_reporter) {
@@ -165,9 +184,12 @@ Mocha.prototype.reporter = function (reporter, reporterOptions) {
     if (!_reporter) {
       throw new Error('invalid reporter "' + reporter + '"');
     }
-    this._reporter = _reporter;
-  }
-  this.options.reporterOptions = reporterOptions;
+    return {
+      fn: _reporter,
+      options: reporterOptions[reporter] || reporterOptions._default || {}
+    };
+  }, this);
+
   return this;
 };
 
@@ -490,7 +512,14 @@ Mocha.prototype.run = function (fn) {
   var options = this.options;
   options.files = this.files;
   var runner = new exports.Runner(suite, options.delay);
-  var reporter = new this._reporter(runner, options);
+
+  // For each loaded reporter constructor, create
+  // an instance and initialize it with the runner
+  var reporters = this._reporters.map(function(reporterConfig) {
+    var _reporter = reporterConfig.fn;
+    options.reporterOptions = reporterConfig.options;
+    return new _reporter(runner, options);
+  });
   runner.ignoreLeaks = options.ignoreLeaks !== false;
   runner.fullStackTrace = options.fullStackTrace;
   runner.hasOnly = options.hasOnly;
@@ -502,21 +531,32 @@ Mocha.prototype.run = function (fn) {
   if (options.globals) {
     runner.globals(options.globals);
   }
+  // Use only the first reporter for growl, since we don't want to
+  // send several notifications for the same test suite
   if (options.growl) {
-    this._growl(runner, reporter);
+    this._growl(runner, reporters[0]);
   }
   if (options.useColors !== undefined) {
     exports.reporters.Base.useColors = options.useColors;
   }
   exports.reporters.Base.inlineDiffs = options.useInlineDiffs;
 
-  function done (failures) {
-    if (reporter.done) {
-      reporter.done(failures, fn);
-    } else {
-      fn && fn(failures);
+  function runnerDone(failures) {
+    function reporterDone(reporterFailures) {
+      if (--remain === 0) {
+        fn && fn(reporterFailures);
+      }
     }
+
+    var remain = reporters.length;
+    reporters.forEach(function(reporter) {
+      if (reporter.done) {
+        reporter.done(failures, reporterDone);
+      } else {
+        reporterDone(failures);
+      }
+    });
   }
 
-  return runner.run(done);
+  return runner.run(runnerDone);
 };

lib/reporters/base.js

@@ -5,6 +5,10 @@
  */
 
 var tty = require('tty');
+var fs = require('fs');
+var mkdirp = require('mkdirp');
+var path = require('path');
+var EOL = require('os').EOL;
 var diff = require('diff');
 var ms = require('../ms');
 var utils = require('../utils');
@@ -235,13 +239,16 @@ exports.list = function (failures) {
  * of tests passed / failed etc.
  *
  * @param {Runner} runner
+ * @param {Object} options runner optional options
  * @api public
  */
 
-function Base (runner) {
+function Base (runner, options) {
   var stats = this.stats = { suites: 0, tests: 0, passes: 0, pending: 0, failures: 0 };
   var failures = this.failures = [];
 
+  this.reporterOptions = options ? options.reporterOptions : null;
+
   if (!runner) {
     return;
   }
@@ -336,6 +343,71 @@ Base.prototype.epilogue = function () {
   console.log();
 };
 
+/**
+ * Opens for writing the file referenced on the `optionName` option
+ * of the reporter options, if any.
+ * Call this method to support writing to this file when calling
+ * write or writeLine.
+ *
+ * @param {string} optionName the name of the option, defaults to 'output'.
+ * @api public
+ */
+Base.prototype.openOutput = function (optionName) {
+  var output = this.reporterOptions && this.reporterOptions[optionName || 'output'];
+  if (output) {
+    if (!fs.createWriteStream) {
+      throw new Error('file output not supported in browser');
+    }
+
+    if (this.fileStream) {
+      throw new Error('file stream already opened');
+    }
+
+    mkdirp.sync(path.dirname(output));
+    this.fileStream = fs.createWriteStream(output);
+  }
+};
+
+/**
+ * Write to reporter output stream.
+ *
+ * @param {string} str
+ * @api public
+ */
+Base.prototype.write = function (str) {
+  if (this.fileStream) {
+    this.fileStream.write(str);
+  } else {
+    process.stdout.write(str);
+  }
+};
+
+/**
+ * Write to reporter output stream, adding an EOL at the end.
+ *
+ * @param {string} line
+ * @api public
+ */
+Base.prototype.writeLine = function (line) {
+  this.write(line + EOL);
+};
+
+/**
+ * Close the output stream and callback with failures.
+ *
+ * @param failures
+ * @param {Function} fn
+ */
+Base.prototype.done = function (failures, fn) {
+  if (this.fileStream) {
+    this.fileStream.end(function () {
+      fn(failures);
+    });
+  } else {
+    fn(failures);
+  }
+};
+
 /**
  * Pad the given `str` to `len`.
  *

lib/reporters/json.js

@@ -5,6 +5,7 @@
  */
 
 var Base = require('./base');
+var inherits = require('../utils').inherits;
 
 /**
  * Expose `JSON`.
@@ -17,16 +18,19 @@ exports = module.exports = JSONReporter;
  *
  * @api public
  * @param {Runner} runner
+ * @param {Object} options Runner optional options
  */
-function JSONReporter (runner) {
-  Base.call(this, runner);
+function JSONReporter (runner, options) {
+  Base.call(this, runner, options);
 
   var self = this;
   var tests = [];
   var pending = [];
   var failures = [];
   var passes = [];
 
+  this.openOutput();
+
   runner.on('test end', function (test) {
     tests.push(test);
   });
@@ -54,10 +58,15 @@ function JSONReporter (runner) {
 
     runner.testResults = obj;
 
-    process.stdout.write(JSON.stringify(obj, null, 2));
+    self.write(JSON.stringify(obj, null, 2));
   });
 }
 
+/**
+ * Inherit from `Base.prototype`.
+ */
+inherits(JSONReporter, Base);
+
 /**
  * Return a plain-object representation of `test`
  * free of cyclic properties etc.