mocha 2.0.1 → 2.1.0

package/README.md

@@ -0,0 +1,226 @@
+ [![Build Status](https://secure.travis-ci.org/mochajs/mocha.png)](http://travis-ci.org/mochajs/mocha)
+
+  [![Mocha test framework](http://f.cl.ly/items/3l1k0n2A1U3M1I1L210p/Screen%20Shot%202012-02-24%20at%202.21.43%20PM.png)](http://mochajs.org)
+
+  Mocha is a simple, flexible, fun JavaScript test framework for node.js and the browser. For more information view the [documentation](http://mochajs.org).
+
+## Contributors
+
+```
+ project  : mocha
+ repo age : 3 years, 4 months
+ active   : 509 days
+ commits  : 1575
+ files    : 153
+ authors  :
+   977	TJ Holowaychuk          62.0%
+   132	Travis Jeffery          8.4%
+    63	Christopher Hiller      4.0%
+    31	Guillermo Rauch         2.0%
+    27	Joshua Appelman         1.7%
+    13	Attila Domokos          0.8%
+    10	John Firebaugh          0.6%
+     8	Nathan Rajlich          0.5%
+     8	Jo Liss                 0.5%
+     6	Mike Pennisi            0.4%
+     6	Brendan Nee             0.4%
+     6	James Carr              0.4%
+     5	Aaron Heckmann          0.3%
+     5	Raynos                  0.3%
+     5	Ryunosuke SATO          0.3%
+     4	hokaccha                0.3%
+     4	Jonathan Ong            0.3%
+     4	Joshua Krall            0.3%
+     4	Domenic Denicola        0.3%
+     4	Forbes Lindesay         0.3%
+     4	Xavier Antoviaque       0.3%
+     4	David da Silva          0.3%
+     3	Ariel Mashraki          0.2%
+     3	Ben Bradley             0.2%
+     3	Merrick Christensen     0.2%
+     3	Andreas Lind Petersen   0.2%
+     3	Nathan Bowser           0.2%
+     3	Cory Thomas             0.2%
+     3	Benjie Gillam           0.2%
+     3	Wil Moore III           0.2%
+     3	Ben Lindsey             0.2%
+     3	Tyson Tate              0.2%
+     3	Paul Miller             0.2%
+     3	eiji.ienaga             0.2%
+     3	Mathieu Desvé           0.2%
+     3	Jesse Dailey            0.2%
+     3	fool2fish               0.2%
+     3	Fredrik Enestad         0.2%
+     3	Sindre Sorhus           0.2%
+     3	Valentin Agachi         0.2%
+     2	jsdevel                 0.1%
+     2	Arian Stolwijk          0.1%
+     2	Juzer Ali               0.1%
+     2	David Henderson         0.1%
+     2	Justin DuJardin         0.1%
+     2	Paul Armstrong          0.1%
+     2	Pete Hawkins            0.1%
+     2	Jonas Westerlund        0.1%
+     2	Quang Van               0.1%
+     2	Simon Gaeremynck        0.1%
+     2	travis jeffery          0.1%
+     2	Dominique Quatravaux    0.1%
+     2	Jacob Wejendorp         0.1%
+     2	Shawn Krisman           0.1%
+     2	FARKAS Máté             0.1%
+     2	Konstantin Käfer        0.1%
+     2	Timo Tijhof             0.1%
+     2	Sean Lang               0.1%
+     2	Quanlong He             0.1%
+     2	Glen Mailer             0.1%
+     2	Alexander Early         0.1%
+     2	Ian Storm Taylor        0.1%
+     2	Brian Beck              0.1%
+     2	Michael Riley           0.1%
+     2	Michael Schoonmaker     0.1%
+     2	domenic                 0.1%
+     2	fcrisci                 0.1%
+     2	Buck Doyle              0.1%
+     2	Nathan Alderson         0.1%
+     1	Mal Graty               0.1%
+     1	Marc Kuo                0.1%
+     1	Matija Marohnić         0.1%
+     1	Matt Robenolt           0.1%
+     1	Matt Smith              0.1%
+     1	Matthew Shanley         0.1%
+     1	Mattias Tidlund         0.1%
+     1	Michael Jackson         0.1%
+     1	Michael Olson           0.1%
+     1	Michal Charemza         0.1%
+     1	Nathan Black            0.1%
+     1	Nick Fitzgerald         0.1%
+     1	Noshir Patel            0.1%
+     1	Panu Horsmalahti        0.1%
+     1	Phil Sung               0.1%
+     1	R56                     0.1%
+     1	Refael Ackermann        0.1%
+     1	Richard Dingwall        0.1%
+     1	Richard Knop            0.1%
+     1	Rob Wu                  0.1%
+     1	Romain Prieto           0.1%
+     1	Roman Neuhauser         0.1%
+     1	Roman Shtylman          0.1%
+     1	Russ Bradberry          0.1%
+     1	Russell Munson          0.1%
+     1	Rustem Mustafin         0.1%
+     1	Salehen Shovon Rahman   0.1%
+     1	Sasha Koss              0.1%
+     1	Seiya Konno             0.1%
+     1	Shaine Hatch            0.1%
+     1	Simon Goumaz            0.1%
+     1	Standa Opichal          0.1%
+     1	Stephen Mathieson       0.1%
+     1	Steve Mason             0.1%
+     1	Tapiwa Kelvin           0.1%
+     1	Teddy Zeenny            0.1%
+     1	Tim Ehat                0.1%
+     1	Vadim Nikitin           0.1%
+     1	Victor Costan           0.1%
+     1	Will Langstroth         0.1%
+     1	Yanis Wang              0.1%
+     1	Yuest Wang              0.1%
+     1	Zsolt Takács            0.1%
+     1	abrkn                   0.1%
+     1	airportyh               0.1%
+     1	badunk                  0.1%
+     1	claudyus                0.1%
+     1	dasilvacontin           0.1%
+     1	fengmk2                 0.1%
+     1	gaye                    0.1%
+     1	grasGendarme            0.1%
+     1	lakmeer                 0.1%
+     1	lodr                    0.1%
+     1	mrShturman              0.1%
+     1	nishigori               0.1%
+     1	omardelarosa            0.1%
+     1	qiuzuhui                0.1%
+     1	samuel goldszmidt       0.1%
+     1	sebv                    0.1%
+     1	startswithaj            0.1%
+     1	tgautier@yahoo.com      0.1%
+     1	traleig1                0.1%
+     1	vlad                    0.1%
+     1	yuitest                 0.1%
+     1	zhiyelee                0.1%
+     1	Adam Crabtree           0.1%
+     1	Andreas Brekken         0.1%
+     1	Andrew Nesbitt          0.1%
+     1	Andrey Popp             0.1%
+     1	Arnaud Brousseau        0.1%
+     1	Atsuya Takagi           0.1%
+     1	Austin Birch            0.1%
+     1	Ben Noordhuis           0.1%
+     1	Bjørge Næss             0.1%
+     1	Brian Lalor             0.1%
+     1	Brian M. Carlson        0.1%
+     1	Brian Moore             0.1%
+     1	Bryan Donovan           0.1%
+     1	C. Scott Ananian        0.1%
+     1	Casey Foster            0.1%
+     1	ChrisWren               0.1%
+     1	Connor Dunn             0.1%
+     1	Corey Butler            0.1%
+     1	Daniel Stockman         0.1%
+     1	Dave McKenna            0.1%
+     1	Denis Bardadym          0.1%
+     1	Devin Weaver            0.1%
+     1	Di Wu                   0.1%
+     1	Diogo Monteiro          0.1%
+     1	Dmitry Shirokov         0.1%
+     1	Dr. Travis Jeffery      0.1%
+     1	Fedor Indutny           0.1%
+     1	Florian Margaine        0.1%
+     1	Frederico Silva         0.1%
+     1	Fredrik Lindin          0.1%
+     1	Gareth Aye              0.1%
+     1	Gareth Murphy           0.1%
+     1	Gavin Mogan             0.1%
+     1	Giovanni Bassi          0.1%
+     1	Glen Huang              0.1%
+     1	Greg Perkins            0.1%
+     1	Harish                  0.1%
+     1	Harry Brundage          0.1%
+     1	Herman Junge            0.1%
+     1	Ian Young               0.1%
+     1	Ivan                    0.1%
+     1	JP Bochi                0.1%
+     1	Jaakko Salonen          0.1%
+     1	Jakub Nešetřil          0.1%
+     1	James Bowes             0.1%
+     1	James Lal               0.1%
+     1	Jan Kopriva             0.1%
+     1	Jason Barry             0.1%
+     1	Javier Aranda           0.1%
+     1	Jean Ponchon            0.1%
+     1	Jeff Kunkle             0.1%
+     1	Jeremy Martin           0.1%
+     1	Jimmy Cuadra            0.1%
+     1	John Doty               0.1%
+     1	Jonathan Creamer        0.1%
+     1	Jonathan Park           0.1%
+     1	Jussi Virtanen          0.1%
+     1	Katie Gengler           0.1%
+     1	Kazuhito Hokamura       0.1%
+     1	Kent C. Dodds           0.1%
+     1	Kevin Conway            0.1%
+     1	Kirill Korolyov         0.1%
+     1	Koen Punt               0.1%
+     1	Laszlo Bacsi            0.1%
+     1	Liam Newman             0.1%
+     1	Linus Unnebäck          0.1%
+     1	László Bácsi            0.1%
+     1	Maciej Małecki          0.1%
+```
+
+## Links
+
+  - [Google Group](http://groups.google.com/group/mochajs)
+  - [Wiki](https://github.com/mochajs/mocha/wiki)
+  - Mocha [Extensions and reporters](https://github.com/mochajs/mocha/wiki)
+
+Mocha also has a chat room on [Slack](https://slack.com). If you'd like to join, [shoot us an email](mailto:tj@travisjeffery.com?subject=mocha%20slack%20room%20invite) from the address you want us to invite you under and we'll happily send you an invite!

package/bin/_mocha

@@ -5,17 +5,13 @@
  */
 
 var program = require('commander')
-  , sprintf = require('util').format
   , path = require('path')
   , fs = require('fs')
-  , glob = require('glob')
   , resolve = path.resolve
   , exists = fs.existsSync || path.existsSync
   , Mocha = require('../')
   , utils = Mocha.utils
-  , interfaces = Mocha.interfaces
   , join = path.join
-  , basename = path.basename
   , cwd = process.cwd()
   , mocha = new Mocha;
 
@@ -65,6 +61,7 @@ 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")
@@ -179,7 +176,10 @@ var optsPath = process.argv.indexOf('--opts') !== -1
 try {
   var opts = fs.readFileSync(optsPath, 'utf8')
     .trim()
-    .split(/\s+/);
+    .split(/\s+/)
+    .filter(function(value) {
+      return value ? true : false;
+    });
 
   process.argv = process.argv
     .slice(0, 2)
@@ -196,9 +196,22 @@ program.parse(process.argv);
 
 Error.stackTraceLimit = Infinity; // TODO: config
 
+// reporter options
+
+var reporterOptions = {};
+if (program.reporterOptions !== undefined) {
+    program.reporterOptions.split(",").forEach(function(opt) {
+        var L = opt.split("=");
+        if (L.length != 2) {
+            throw new Error("invalid reporter option '" + opt + "'");
+        }
+        reporterOptions[L[0]] = L[1];
+    });
+}
+
 // reporter
 
-mocha.reporter(program.reporter);
+mocha.reporter(program.reporter, reporterOptions);
 
 // interface
 
@@ -282,6 +295,7 @@ program.compilers.forEach(function(c) {
   if (mod[0] == '.') mod = join(process.cwd(), mod);
   require(mod);
   extensions.push(ext);
+  program.watchExtensions.push(ext);
 });
 
 // requires
@@ -325,7 +339,7 @@ if (program.watch) {
   });
 
 
-  var watchFiles = utils.files(cwd, [ 'js', 'coffee', 'litcoffee', 'coffee.md' ].concat(program.watchExtensions));
+  var watchFiles = utils.files(cwd, [ 'js' ].concat(program.watchExtensions));
   var runAgain = false;
 
   function loadAndRun() {

package/bin/mocha

@@ -54,3 +54,10 @@ proc.on('exit', function (code, signal) {
     }
   });
 });
+
+// terminate children.
+process.on('SIGINT', function () {
+  proc.kill('SIGINT'); // calls runner.abort()
+  proc.kill('SIGTERM'); // if that didn't work, we're probably in an infinite loop, so make it die.
+  process.kill(process.pid, 'SIGINT');
+});

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;
+}