mocha 2.3.0 → 2.3.4

package/HISTORY.md

@@ -1,4 +1,51 @@
 
+2.3.4 / 2015-11-15
+==================
+
+  * Update debug dependency to 2.2.0
+  * remove duplication of mocha.opts on process.argv
+  * Fix typo in test/reporters/nyan.js
+
+2.3.3 / 2015-09-19
+==================
+
+ * [#1875] - Fix Markdown reporter exceeds maximum call stack size ([@danielstjules])
+ * [#1864] - Fix xunit missing output with --reporter-options output ([@danielstjules])
+ * [#1846] - Support all harmony flags ([@danielstjules])
+ * Fix fragile xunit reporter spec ([@danielstjules])
+ * [#1669] - Fix catch uncaught errors outside test suite execution ([@danielstjules])
+ * [#1868] - Revert jade to support npm < v1.3.7 ([@danielstjules])
+ * [#1766] - Don't remove modules/components from stack trace in the browser ([@danielstjules])
+ * [#1798] - Fix correctly attribute mutiple done err with hooks ([@danielstjules])
+ * Fix use utils.reduce for IE8 compatibility ([@wsw0108])
+ * Some linting errors fixed by [@danielstjules]
+ * Call the inspect() function if message is not set ([@kevinburke])
+
+[#1875]: https://github.com/mochajs/mocha/issues/1875
+[#1864]: https://github.com/mochajs/mocha/issues/1864
+[#1846]: https://github.com/mochajs/mocha/issues/1846
+[#1669]: https://github.com/mochajs/mocha/issues/1669
+[#1868]: https://github.com/mochajs/mocha/issues/1868
+[#1766]: https://github.com/mochajs/mocha/issues/1766
+[#1798]: https://github.com/mochajs/mocha/issues/1798
+[@danielstjules]: https://github.com/danielstjules
+[@wsw0108]: https://github.com/wsw0108
+[@kevinburke]: https://github.com/kevinburke
+
+2.3.2 / 2015-09-07
+==================
+ * [#1868] - Fix compatibility with older versions of NPM ([@boneskull])
+
+  [#1868]: https://github.com/mochajs/mocha/issues/1868
+
+2.3.1 / 2015-09-06
+==================
+
+  * [#1812] - Fix: Bail flag causes before() hooks to be run even after a failure ([@aaroncrows])
+
+  [#1812]: https://github.com/mochajs/mocha/issues/1812
+  [aaroncrows]: https://github.com/aaroncrows
+
 2.3.0 / 2015-08-30
 ==================
 
@@ -10,7 +57,7 @@
   * [#1230] - More descriptive beforeEach/afterEach messages ([@duncanbeevers])
   * [#1787] - Scope loading behaviour instead of using early return ([@aryeguy])
   * [#1789] - Fix: html-runner crashing ([@sunesimonsen])
-  * [#1749] - Fix maximum call stack error on large amount of tests ([@tinganho])  
+  * [#1749] - Fix maximum call stack error on large amount of tests ([@tinganho])
   * [#1230] - Decorate failed hook titles with test title ([@duncanbeevers])
   * [#1260] - Build using Browserify ([@ndhoule])
   * [#1728] - Don't use `__proto__` ([@ndhoule])
@@ -19,7 +66,7 @@
   * [#1766] - Fix overly aggressive stack suppression ([@moll])
   * [#1752] - Avoid potential infinite loop ([@gsilk])
   * [#1761] - Fix problems running under PhantomJS ([@chromakode])
-  * [#1700] - Fix more problems running under PhantomJS ([@jbnicolai])  
+  * [#1700] - Fix more problems running under PhantomJS ([@jbnicolai])
   * [#1774] - Support escaped spaces in CLI options ([@adamgruber])
   * [#1687] - Fix HTML reporter links with special chars ([@benvinegar])
   * [#1359] - Adopt code style and enforce it using ESLint ([@ndhoule] w/ assist from [@jbnicolai] & [@boneskull])

package/bin/_mocha

@@ -81,16 +81,8 @@ program
   .option('--compilers <ext>:<module>,...', 'use the given module(s) to compile files', list, [])
   .option('--debug-brk', "enable node's debugger breaking on the first line")
   .option('--globals <names>', 'allow the given comma-delimited global [names]', list, [])
-  .option('--harmony', 'enable all harmony features (except typeof)')
   .option('--es_staging', 'enable all staged features')
-  .option('--harmony-collections', 'enable harmony collections (sets, maps, and weak maps)')
-  .option('--harmony-generators', 'enable harmony generators')
-  .option('--harmony-proxies', 'enable harmony proxies')
-  .option('--harmony_shipping', 'enable all shipped harmony fetaures (iojs)')
-  .option('--harmony_arrow_functions', 'enable "harmony arrow functions" (iojs)')
-  .option('--harmony_rest_parameters', 'enable "harmony rest parameters" (iojs)')
-  .option('--harmony_proxies', 'enable "harmony proxies" (iojs)')
-  .option('--harmony_classes', 'enable "harmony classes" (iojs)')
+  .option('--harmony<_classes,_generators,...>', 'all node --harmony* flags are available')
   .option('--inline-diffs', 'display actual/expected differences inline within each string')
   .option('--interfaces', 'display available interfaces')
   .option('--no-deprecation', 'silence deprecation warnings')

package/bin/mocha

@@ -8,12 +8,7 @@
 var spawn = require('child_process').spawn,
   path = require('path'),
   fs = require('fs'),
-  args = [path.join(__dirname, '_mocha')],
-  getOptions = require('./options');
-
-// load mocha.opts into process.argv
-
-getOptions();
+  args = [path.join(__dirname, '_mocha')];
 
 process.argv.slice(2).forEach(function(arg){
   var flag = arg.split('=')[0];
@@ -34,24 +29,7 @@ process.argv.slice(2).forEach(function(arg){
       args.unshift('--expose-gc');
       break;
     case '--gc-global':
-    case '--harmony':
     case '--es_staging':
-    case '--harmony_arrays':
-    case '--harmony_array_includes':
-    case '--harmony_arrow_functions':
-    case '--harmony_classes':
-    case '--harmony-collections':
-    case '--harmony_collections':
-    case '--harmony-generators':
-    case '--harmony_generators':
-    case '--harmony_modules':
-    case '--harmony-proxies':
-    case '--harmony_proxies':
-    case '--harmony_regexps':
-    case '--harmony_shipping':
-    case '--harmony_sloppy':
-    case '--harmony_rest_parameters':
-    case '--harmony_unicode':
     case '--no-deprecation':
     case '--prof':
     case '--throw-deprecation':
@@ -60,7 +38,8 @@ process.argv.slice(2).forEach(function(arg){
       args.unshift(arg);
       break;
     default:
-      if (0 == arg.indexOf('--trace')) args.unshift(arg);
+      if (0 == arg.indexOf('--harmony')) args.unshift(arg);
+      else if (0 == arg.indexOf('--trace')) args.unshift(arg);
       else if (0 == arg.indexOf('--max-old-space-size')) args.unshift(arg);
       else args.push(arg);
       break;

package/lib/browser/diff.js

@@ -0,0 +1,369 @@
+/* See LICENSE file for terms of use */
+
+/*
+ * Text diff implementation.
+ *
+ * This library supports the following APIS:
+ * JsDiff.diffChars: Character by character diff
+ * JsDiff.diffWords: Word (as defined by \b regex) diff which ignores whitespace
+ * JsDiff.diffLines: Line based diff
+ *
+ * JsDiff.diffCss: Diff targeted at CSS content
+ *
+ * These methods are based on the implementation proposed in
+ * "An O(ND) Difference Algorithm and its Variations" (Myers, 1986).
+ * http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.4.6927
+ */
+var JsDiff = (function() {
+  /*jshint maxparams: 5*/
+  function clonePath(path) {
+    return { newPos: path.newPos, components: path.components.slice(0) };
+  }
+  function removeEmpty(array) {
+    var ret = [];
+    for (var i = 0; i < array.length; i++) {
+      if (array[i]) {
+        ret.push(array[i]);
+      }
+    }
+    return ret;
+  }
+  function escapeHTML(s) {
+    var n = s;
+    n = n.replace(/&/g, '&amp;');
+    n = n.replace(/</g, '&lt;');
+    n = n.replace(/>/g, '&gt;');
+    n = n.replace(/"/g, '&quot;');
+
+    return n;
+  }
+
+  var Diff = function(ignoreWhitespace) {
+    this.ignoreWhitespace = ignoreWhitespace;
+  };
+  Diff.prototype = {
+      diff: function(oldString, newString) {
+        // Handle the identity case (this is due to unrolling editLength == 0
+        if (newString === oldString) {
+          return [{ value: newString }];
+        }
+        if (!newString) {
+          return [{ value: oldString, removed: true }];
+        }
+        if (!oldString) {
+          return [{ value: newString, added: true }];
+        }
+
+        newString = this.tokenize(newString);
+        oldString = this.tokenize(oldString);
+
+        var newLen = newString.length, oldLen = oldString.length;
+        var maxEditLength = newLen + oldLen;
+        var bestPath = [{ newPos: -1, components: [] }];
+
+        // Seed editLength = 0
+        var oldPos = this.extractCommon(bestPath[0], newString, oldString, 0);
+        if (bestPath[0].newPos+1 >= newLen && oldPos+1 >= oldLen) {
+          return bestPath[0].components;
+        }
+
+        for (var editLength = 1; editLength <= maxEditLength; editLength++) {
+          for (var diagonalPath = -1*editLength; diagonalPath <= editLength; diagonalPath+=2) {
+            var basePath;
+            var addPath = bestPath[diagonalPath-1],
+                removePath = bestPath[diagonalPath+1];
+            oldPos = (removePath ? removePath.newPos : 0) - diagonalPath;
+            if (addPath) {
+              // No one else is going to attempt to use this value, clear it
+              bestPath[diagonalPath-1] = undefined;
+            }
+
+            var canAdd = addPath && addPath.newPos+1 < newLen;
+            var canRemove = removePath && 0 <= oldPos && oldPos < oldLen;
+            if (!canAdd && !canRemove) {
+              bestPath[diagonalPath] = undefined;
+              continue;
+            }
+
+            // Select the diagonal that we want to branch from. We select the prior
+            // path whose position in the new string is the farthest from the origin
+            // and does not pass the bounds of the diff graph
+            if (!canAdd || (canRemove && addPath.newPos < removePath.newPos)) {
+              basePath = clonePath(removePath);
+              this.pushComponent(basePath.components, oldString[oldPos], undefined, true);
+            } else {
+              basePath = clonePath(addPath);
+              basePath.newPos++;
+              this.pushComponent(basePath.components, newString[basePath.newPos], true, undefined);
+            }
+
+            var oldPos = this.extractCommon(basePath, newString, oldString, diagonalPath);
+
+            if (basePath.newPos+1 >= newLen && oldPos+1 >= oldLen) {
+              return basePath.components;
+            } else {
+              bestPath[diagonalPath] = basePath;
+            }
+          }
+        }
+      },
+
+      pushComponent: function(components, value, added, removed) {
+        var last = components[components.length-1];
+        if (last && last.added === added && last.removed === removed) {
+          // We need to clone here as the component clone operation is just
+          // as shallow array clone
+          components[components.length-1] =
+            {value: this.join(last.value, value), added: added, removed: removed };
+        } else {
+          components.push({value: value, added: added, removed: removed });
+        }
+      },
+      extractCommon: function(basePath, newString, oldString, diagonalPath) {
+        var newLen = newString.length,
+            oldLen = oldString.length,
+            newPos = basePath.newPos,
+            oldPos = newPos - diagonalPath;
+        while (newPos+1 < newLen && oldPos+1 < oldLen && this.equals(newString[newPos+1], oldString[oldPos+1])) {
+          newPos++;
+          oldPos++;
+
+          this.pushComponent(basePath.components, newString[newPos], undefined, undefined);
+        }
+        basePath.newPos = newPos;
+        return oldPos;
+      },
+
+      equals: function(left, right) {
+        var reWhitespace = /\S/;
+        if (this.ignoreWhitespace && !reWhitespace.test(left) && !reWhitespace.test(right)) {
+          return true;
+        } else {
+          return left === right;
+        }
+      },
+      join: function(left, right) {
+        return left + right;
+      },
+      tokenize: function(value) {
+        return value;
+      }
+  };
+
+  var CharDiff = new Diff();
+
+  var WordDiff = new Diff(true);
+  var WordWithSpaceDiff = new Diff();
+  WordDiff.tokenize = WordWithSpaceDiff.tokenize = function(value) {
+    return removeEmpty(value.split(/(\s+|\b)/));
+  };
+
+  var CssDiff = new Diff(true);
+  CssDiff.tokenize = function(value) {
+    return removeEmpty(value.split(/([{}:;,]|\s+)/));
+  };
+
+  var LineDiff = new Diff();
+  LineDiff.tokenize = function(value) {
+    var retLines = [],
+        lines = value.split(/^/m);
+
+    for(var i = 0; i < lines.length; i++) {
+      var line = lines[i],
+          lastLine = lines[i - 1];
+
+      // Merge lines that may contain windows new lines
+      if (line == '\n' && lastLine && lastLine[lastLine.length - 1] === '\r') {
+        retLines[retLines.length - 1] += '\n';
+      } else if (line) {
+        retLines.push(line);
+      }
+    }
+
+    return retLines;
+  };
+
+  return {
+    Diff: Diff,
+
+    diffChars: function(oldStr, newStr) { return CharDiff.diff(oldStr, newStr); },
+    diffWords: function(oldStr, newStr) { return WordDiff.diff(oldStr, newStr); },
+    diffWordsWithSpace: function(oldStr, newStr) { return WordWithSpaceDiff.diff(oldStr, newStr); },
+    diffLines: function(oldStr, newStr) { return LineDiff.diff(oldStr, newStr); },
+
+    diffCss: function(oldStr, newStr) { return CssDiff.diff(oldStr, newStr); },
+
+    createPatch: function(fileName, oldStr, newStr, oldHeader, newHeader) {
+      var ret = [];
+
+      ret.push('Index: ' + fileName);
+      ret.push('===================================================================');
+      ret.push('--- ' + fileName + (typeof oldHeader === 'undefined' ? '' : '\t' + oldHeader));
+      ret.push('+++ ' + fileName + (typeof newHeader === 'undefined' ? '' : '\t' + newHeader));
+
+      var diff = LineDiff.diff(oldStr, newStr);
+      if (!diff[diff.length-1].value) {
+        diff.pop();   // Remove trailing newline add
+      }
+      diff.push({value: '', lines: []});   // Append an empty value to make cleanup easier
+
+      function contextLines(lines) {
+        return lines.map(function(entry) { return ' ' + entry; });
+      }
+      function eofNL(curRange, i, current) {
+        var last = diff[diff.length-2],
+            isLast = i === diff.length-2,
+            isLastOfType = i === diff.length-3 && (current.added !== last.added || current.removed !== last.removed);
+
+        // Figure out if this is the last line for the given file and missing NL
+        if (!/\n$/.test(current.value) && (isLast || isLastOfType)) {
+          curRange.push('\');
+        }
+      }
+
+      var oldRangeStart = 0, newRangeStart = 0, curRange = [],
+          oldLine = 1, newLine = 1;
+      for (var i = 0; i < diff.length; i++) {
+        var current = diff[i],
+            lines = current.lines || current.value.replace(/\n$/, '').split('\n');
+        current.lines = lines;
+
+        if (current.added || current.removed) {
+          if (!oldRangeStart) {
+            var prev = diff[i-1];
+            oldRangeStart = oldLine;
+            newRangeStart = newLine;
+
+            if (prev) {
+              curRange = contextLines(prev.lines.slice(-4));
+              oldRangeStart -= curRange.length;
+              newRangeStart -= curRange.length;
+            }
+          }
+          curRange.push.apply(curRange, lines.map(function(entry) { return (current.added?'+':'-') + entry; }));
+          eofNL(curRange, i, current);
+
+          if (current.added) {
+            newLine += lines.length;
+          } else {
+            oldLine += lines.length;
+          }
+        } else {
+          if (oldRangeStart) {
+            // Close out any changes that have been output (or join overlapping)
+            if (lines.length <= 8 && i < diff.length-2) {
+              // Overlapping
+              curRange.push.apply(curRange, contextLines(lines));
+            } else {
+              // end the range and output
+              var contextSize = Math.min(lines.length, 4);
+              ret.push(
+                  '@@ -' + oldRangeStart + ',' + (oldLine-oldRangeStart+contextSize)
+                  + ' +' + newRangeStart + ',' + (newLine-newRangeStart+contextSize)
+                  + ' @@');
+              ret.push.apply(ret, curRange);
+              ret.push.apply(ret, contextLines(lines.slice(0, contextSize)));
+              if (lines.length <= 4) {
+                eofNL(ret, i, current);
+              }
+
+              oldRangeStart = 0;  newRangeStart = 0; curRange = [];
+            }
+          }
+          oldLine += lines.length;
+          newLine += lines.length;
+        }
+      }
+
+      return ret.join('\n') + '\n';
+    },
+
+    applyPatch: function(oldStr, uniDiff) {
+      var diffstr = uniDiff.split('\n');
+      var diff = [];
+      var remEOFNL = false,
+          addEOFNL = false;
+
+      for (var i = (diffstr[0][0]==='I'?4:0); i < diffstr.length; i++) {
+        if(diffstr[i][0] === '@') {
+          var meh = diffstr[i].split(/@@ -(\d+),(\d+) \+(\d+),(\d+) @@/);
+          diff.unshift({
+            start:meh[3],
+            oldlength:meh[2],
+            oldlines:[],
+            newlength:meh[4],
+            newlines:[]
+          });
+        } else if(diffstr[i][0] === '+') {
+          diff[0].newlines.push(diffstr[i].substr(1));
+        } else if(diffstr[i][0] === '-') {
+          diff[0].oldlines.push(diffstr[i].substr(1));
+        } else if(diffstr[i][0] === ' ') {
+          diff[0].newlines.push(diffstr[i].substr(1));
+          diff[0].oldlines.push(diffstr[i].substr(1));
+        } else if(diffstr[i][0] === '\\') {
+          if (diffstr[i-1][0] === '+') {
+            remEOFNL = true;
+          } else if(diffstr[i-1][0] === '-') {
+            addEOFNL = true;
+          }
+        }
+      }
+
+      var str = oldStr.split('\n');
+      for (var i = diff.length - 1; i >= 0; i--) {
+        var d = diff[i];
+        for (var j = 0; j < d.oldlength; j++) {
+          if(str[d.start-1+j] !== d.oldlines[j]) {
+            return false;
+          }
+        }
+        Array.prototype.splice.apply(str,[d.start-1,+d.oldlength].concat(d.newlines));
+      }
+
+      if (remEOFNL) {
+        while (!str[str.length-1]) {
+          str.pop();
+        }
+      } else if (addEOFNL) {
+        str.push('');
+      }
+      return str.join('\n');
+    },
+
+    convertChangesToXML: function(changes){
+      var ret = [];
+      for ( var i = 0; i < changes.length; i++) {
+        var change = changes[i];
+        if (change.added) {
+          ret.push('<ins>');
+        } else if (change.removed) {
+          ret.push('<del>');
+        }
+
+        ret.push(escapeHTML(change.value));
+
+        if (change.added) {
+          ret.push('</ins>');
+        } else if (change.removed) {
+          ret.push('</del>');
+        }
+      }
+      return ret.join('');
+    },
+
+    // See: http://code.google.com/p/google-diff-match-patch/wiki/API
+    convertChangesToDMP: function(changes){
+      var ret = [], change;
+      for ( var i = 0; i < changes.length; i++) {
+        change = changes[i];
+        ret.push([(change.added ? 1 : change.removed ? -1 : 0), change.value]);
+      }
+      return ret;
+    }
+  };
+})();
+
+if (typeof module !== 'undefined') {
+    module.exports = JsDiff;
+}

package/lib/hook.js

@@ -3,7 +3,7 @@
  */
 
 var Runnable = require('./runnable');
-var create = require('lodash.create');
+var inherits = require('./utils').inherits;
 
 /**
  * Expose `Hook`.
@@ -26,10 +26,7 @@ function Hook(title, fn) {
 /**
  * Inherit from `Runnable.prototype`.
  */
-
-Hook.prototype = create(Runnable.prototype, {
-  constructor: Hook
-});
+inherits(Hook, Runnable);
 
 /**
  * Get or set the test `err`.

package/lib/mocha.js

@@ -85,7 +85,7 @@ function Mocha(options) {
   this.ui(options.ui);
   this.bail(options.bail);
   this.reporter(options.reporter, options.reporterOptions);
-  if (options.timeout != null) {
+  if (typeof options.timeout !== 'undefined' && options.timeout !== null) {
     this.timeout(options.timeout);
   }
   this.useColors(options.useColors);

package/lib/reporters/base.js

@@ -169,7 +169,14 @@ exports.list = function(failures) {
     // msg
     var msg;
     var err = test.err;
-    var message = err.message || '';
+    var message;
+    if (err.message) {
+      message = err.message;
+    } else if (typeof err.inspect === 'function') {
+      message = err.inspect() + '';
+    } else {
+      message = '';
+    }
     var stack = err.stack || message;
     var index = stack.indexOf(message);
     var actual = err.actual;
@@ -401,7 +408,7 @@ function unifiedDiff(err, escape) {
     return indent + line;
   }
   function notBlank(line) {
-    return line != null;
+    return typeof line !== 'undefined' && line !== null;
   }
   var msg = diff.createPatch('string', err.actual, err.expected);
   var lines = msg.split('\n').splice(4);

package/lib/reporters/dot.js

@@ -3,7 +3,7 @@
  */
 
 var Base = require('./base');
-var create = require('lodash.create');
+var inherits = require('../utils').inherits;
 var color = Base.color;
 
 /**
@@ -63,7 +63,4 @@ function Dot(runner) {
 /**
  * Inherit from `Base.prototype`.
  */
-
-Dot.prototype = create(Base.prototype, {
-  constructor: Dot
-});
+inherits(Dot, Base);

package/lib/reporters/landing.js

@@ -3,7 +3,7 @@
  */
 
 var Base = require('./base');
-var create = require('lodash.create');
+var inherits = require('../utils').inherits;
 var cursor = Base.cursor;
 var color = Base.color;
 
@@ -89,7 +89,4 @@ function Landing(runner) {
 /**
  * Inherit from `Base.prototype`.
  */
-
-Landing.prototype = create(Base.prototype, {
-  constructor: Landing
-});
+inherits(Landing, Base);

package/lib/reporters/list.js

@@ -3,7 +3,7 @@
  */
 
 var Base = require('./base');
-var create = require('lodash.create');
+var inherits = require('../utils').inherits;
 var color = Base.color;
 var cursor = Base.cursor;
 
@@ -58,7 +58,4 @@ function List(runner) {
 /**
  * Inherit from `Base.prototype`.
  */
-
-List.prototype = create(Base.prototype, {
-  constructor: List
-});
+inherits(List, Base);

package/lib/reporters/markdown.js

@@ -38,7 +38,7 @@ function Markdown(runner) {
     var key = SUITE_PREFIX + suite.title;
 
     obj = obj[key] = obj[key] || { suite: suite };
-    suite.suites.forEach(function() {
+    suite.suites.forEach(function(suite) {
       mapTOC(suite, obj);
     });
 

package/lib/reporters/min.js

@@ -3,7 +3,7 @@
  */
 
 var Base = require('./base');
-var create = require('lodash.create');
+var inherits = require('../utils').inherits;
 
 /**
  * Expose `Min`.
@@ -33,7 +33,4 @@ function Min(runner) {
 /**
  * Inherit from `Base.prototype`.
  */
-
-Min.prototype = create(Base.prototype, {
-  constructor: Min
-});
+inherits(Min, Base);

package/lib/reporters/nyan.js

@@ -3,7 +3,7 @@
  */
 
 var Base = require('./base');
-var create = require('lodash.create');
+var inherits = require('../utils').inherits;
 
 /**
  * Expose `Dot`.
@@ -62,10 +62,7 @@ function NyanCat(runner) {
 /**
  * Inherit from `Base.prototype`.
  */
-
-NyanCat.prototype = create(Base.prototype, {
-  constructor: NyanCat
-});
+inherits(NyanCat, Base);
 
 /**
  * Draw the nyan cat

package/lib/reporters/progress.js

@@ -3,7 +3,7 @@
  */
 
 var Base = require('./base');
-var create = require('lodash.create');
+var inherits = require('../utils').inherits;
 var color = Base.color;
 var cursor = Base.cursor;
 
@@ -86,7 +86,4 @@ function Progress(runner, options) {
 /**
  * Inherit from `Base.prototype`.
  */
-
-Progress.prototype = create(Base.prototype, {
-  constructor: Progress
-});
+inherits(Progress, Base);