teabag 0.5.2 → 0.5.3

data/README.md

@@ -389,16 +389,18 @@ Specify if you want color output by default.
 
 We know that testing usually requires more than just the test framework, so we've included some of the libraries that we use on a regular basis.
 
-- [jasmine-jquery.js](https://github.com/velesin/jasmine-jquery) jQuery matchers and fixture support (Jasmine).
-- [expect.js](https://github.com/LearnBoost/expect.js) Minimalistic BDD assertion toolkit (Mocha).
-- [Sinon.JS](https://github.com/cjohansen/Sinon.JS) Great for stubbing / spying, and mocking Ajax.
+- [Sinon.JS](http://sinonjs.org) Standalone test spies, stubs and mocks for JavaScript. No dependencies, works with any unit testing framework.
+- [ChaiJS](http://chaijs.com/) BDD / TDD assertion library for node and the browser that can be delightfully paired with any javascript testing framework.
+- [expect.js](https://github.com/LearnBoost/expect.js) Minimalistic BDD assertion toolkit based on should.js.
+- [jasmine-jquery.js](https://github.com/velesin/jasmine-jquery) A set of custom matchers for jQuery, and an API for handling HTML fixtures in your specs.
 
 You can require these files in your spec helper by using:
 
 ```javascript
-//=require support/jasmine-jquery
 //=require support/sinon
+//=require support/chai
 //=require support/expect
+//=require support/jasmine-jquery
 ```
 
 

data/app/assets/javascripts/teabag-jasmine.js

@@ -3022,7 +3022,7 @@ jasmine.version_= {
       _ref = Teabag.suites.all;
       for (_i = 0, _len = _ref.length; _i < _len; _i++) {
         suite = _ref[_i];
-        options.push("<option" + (Teabag.suites.active === suite ? " selected='selected'" : "") + " value=\"" + suite + "\">" + suite + " suite</option>");
+        options.push("<option" + (Teabag.suites.active === suite ? " selected='selected'" : "") + " value=\"" + suite + "\">" + suite + "</option>");
       }
       return "<select id=\"teabag-suite-select\">" + (options.join("")) + "</select>";
     };
@@ -3036,7 +3036,7 @@ jasmine.version_= {
       if (this.filters.length) {
         this.setClass("filter", "teabag-filtered");
       }
-      return this.setHtml("filter-list", "<li>" + (this.filters.join("</li><li>")) + "</li>", true);
+      return this.setHtml("filter-list", "<li>" + (this.filters.join("</li><li>")), true);
     };
 
     HTML.prototype.reportRunnerStarting = function(runner) {

data/app/assets/javascripts/teabag-mocha.js

@@ -58,6 +58,293 @@
   }); // module: browser/debug.js
 
   require.register("browser/diff.js", function(module, exports, require){
+    /* See license.txt for terms of usage */
+
+    /*
+     * 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() {
+      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 fbDiff = function(ignoreWhitespace) {
+        this.ignoreWhitespace = ignoreWhitespace;
+      };
+      fbDiff.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 fbDiff();
+
+      var WordDiff = new fbDiff(true);
+      WordDiff.tokenize = function(value) {
+        return removeEmpty(value.split(/(\s+|\b)/));
+      };
+
+      var CssDiff = new fbDiff(true);
+      CssDiff.tokenize = function(value) {
+        return removeEmpty(value.split(/([{}:;,]|\s+)/));
+      };
+
+      var LineDiff = new fbDiff();
+      LineDiff.tokenize = function(value) {
+        return value.split(/^/m);
+      };
+
+      return {
+        diffChars: function(oldStr, newStr) { return CharDiff.diff(oldStr, newStr); },
+        diffWords: function(oldStr, newStr) { return WordDiff.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';
+        },
+
+        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("");
+        }
+      };
+    })();
+
+    if (typeof module !== "undefined") {
+      module.exports = JsDiff;
+    }
 
   }); // module: browser/diff.js
 
@@ -494,7 +781,9 @@
      * Inherit from `Runnable.prototype`.
      */
 
-    Hook.prototype = new Runnable;
+    function F(){};
+    F.prototype = Runnable.prototype;
+    Hook.prototype = new F;
     Hook.prototype.constructor = Hook;
 
 
@@ -1005,6 +1294,7 @@
      *   - `reporter` reporter instance, defaults to `mocha.reporters.Dot`
      *   - `globals` array of accepted globals
      *   - `timeout` timeout in milliseconds
+     *   - `bail` bail on the first test failure
      *   - `slow` milliseconds to wait before considering a test slow
      *   - `ignoreLeaks` ignore global leaks
      *   - `grep` string or regexp to filter tests with
@@ -1020,11 +1310,25 @@
       this.grep(options.grep);
       this.suite = new exports.Suite('', new exports.Context);
       this.ui(options.ui);
+      this.bail(options.bail);
       this.reporter(options.reporter);
       if (options.timeout) this.timeout(options.timeout);
       if (options.slow) this.slow(options.slow);
     }
 
+    /**
+     * Enable or disable bailing on the first failure.
+     *
+     * @param {Boolean} [bail]
+     * @api public
+     */
+
+    Mocha.prototype.bail = function(bail){
+      if (0 == arguments.length) bail = true;
+      this.suite.bail(bail);
+      return this;
+    };
+
     /**
      * Add test `file`.
      *
@@ -1040,7 +1344,7 @@
     /**
      * Set reporter to `reporter`, defaults to "dot".
      *
-     * @param {String|Function} reporter name of a reporter or a reporter constructor
+     * @param {String|Function} reporter name or constructor
      * @api public
      */
 
@@ -1846,7 +2150,9 @@
      * Inherit from `Base.prototype`.
      */
 
-    Dot.prototype = new Base;
+    function F(){};
+    F.prototype = Base.prototype;
+    Dot.prototype = new F;
     Dot.prototype.constructor = Dot;
 
   }); // module: reporters/dot.js
@@ -2073,7 +2379,7 @@
 
           on(h2, 'click', function(){
             pre.style.display = 'none' == pre.style.display
-                ? 'inline-block'
+                ? 'block'
                 : 'none';
           });
 
@@ -2578,7 +2884,9 @@
      * Inherit from `Base.prototype`.
      */
 
-    Landing.prototype = new Base;
+    function F(){};
+    F.prototype = Base.prototype;
+    Landing.prototype = new F;
     Landing.prototype.constructor = Landing;
 
   }); // module: reporters/landing.js
@@ -2647,7 +2955,9 @@
      * Inherit from `Base.prototype`.
      */
 
-    List.prototype = new Base;
+    function F(){};
+    F.prototype = Base.prototype;
+    List.prototype = new F;
     List.prototype.constructor = List;
 
 
@@ -2679,7 +2989,6 @@
 
       var self = this
           , stats = this.stats
-          , total = runner.total
           , level = 0
           , buf = '';
 
@@ -2786,7 +3095,9 @@
      * Inherit from `Base.prototype`.
      */
 
-    Min.prototype = new Base;
+    function F(){};
+    F.prototype = Base.prototype;
+    Min.prototype = new F;
     Min.prototype.constructor = Min;
 
   }); // module: reporters/min.js
@@ -3050,7 +3361,9 @@
      * Inherit from `Base.prototype`.
      */
 
-    NyanCat.prototype = new Base;
+    function F(){};
+    F.prototype = Base.prototype;
+    NyanCat.prototype = new F;
     NyanCat.prototype.constructor = NyanCat;
 
 
@@ -3142,7 +3455,9 @@
      * Inherit from `Base.prototype`.
      */
 
-    Progress.prototype = new Base;
+    function F(){};
+    F.prototype = Base.prototype;
+    Progress.prototype = new F;
     Progress.prototype.constructor = Progress;
 
 
@@ -3235,7 +3550,9 @@
      * Inherit from `Base.prototype`.
      */
 
-    Spec.prototype = new Base;
+    function F(){};
+    F.prototype = Base.prototype;
+    Spec.prototype = new F;
     Spec.prototype.constructor = Spec;
 
 
@@ -3271,7 +3588,7 @@
           , stats = this.stats
           , n = 1
           , passes = 0
-          , failures = 1;
+          , failures = 0;
 
       runner.on('start', function(){
         var total = runner.grepTotal(runner.suite);
@@ -3294,7 +3611,7 @@
       runner.on('fail', function(test, err){
         failures++;
         console.log('not ok %d %s', n, title(test));
-        console.log(err.stack.replace(/^/gm, '  '));
+        if (err.stack) console.log(err.stack.replace(/^/gm, '  '));
       });
 
       runner.on('end', function(){
@@ -3454,7 +3771,9 @@
      * Inherit from `Base.prototype`.
      */
 
-    XUnit.prototype = new Base;
+    function F(){};
+    F.prototype = Base.prototype;
+    XUnit.prototype = new F;
     XUnit.prototype.constructor = XUnit;
 
 
@@ -3562,7 +3881,9 @@
      * Inherit from `EventEmitter.prototype`.
      */
 
-    Runnable.prototype = new EventEmitter;
+    function F(){};
+    F.prototype = EventEmitter.prototype;
+    Runnable.prototype = new F;
     Runnable.prototype.constructor = Runnable;
 
 
@@ -3707,7 +4028,7 @@
       if (this.async) {
         try {
           this.fn.call(ctx, function(err){
-            if (toString.call(err) === "[object Error]") return done(err);
+            if (err instanceof Error || toString.call(err) === "[object Error]") return done(err);
             if (null != err) return done(new Error('done() invoked with non-Error: ' + err));
             done();
           });
@@ -3801,7 +4122,9 @@
      * Inherit from `EventEmitter.prototype`.
      */
 
-    Runner.prototype = new EventEmitter;
+    function F(){};
+    F.prototype = EventEmitter.prototype;
+    Runner.prototype = new F;
     Runner.prototype.constructor = Runner;
 
 
@@ -4341,7 +4664,9 @@
      * Inherit from `EventEmitter.prototype`.
      */
 
-    Suite.prototype = new EventEmitter;
+    function F(){};
+    F.prototype = EventEmitter.prototype;
+    Suite.prototype = new F;
     Suite.prototype.constructor = Suite;
 
 
@@ -4606,7 +4931,9 @@
      * Inherit from `Runnable.prototype`.
      */
 
-    Test.prototype = new Runnable;
+    function F(){};
+    F.prototype = Runnable.prototype;
+    Test.prototype = new F;
     Test.prototype.constructor = Test;
 
 
@@ -5433,7 +5760,7 @@
       _ref = Teabag.suites.all;
       for (_i = 0, _len = _ref.length; _i < _len; _i++) {
         suite = _ref[_i];
-        options.push("<option" + (Teabag.suites.active === suite ? " selected='selected'" : "") + " value=\"" + suite + "\">" + suite + " suite</option>");
+        options.push("<option" + (Teabag.suites.active === suite ? " selected='selected'" : "") + " value=\"" + suite + "\">" + suite + "</option>");
       }
       return "<select id=\"teabag-suite-select\">" + (options.join("")) + "</select>";
     };
@@ -5447,7 +5774,7 @@
       if (this.filters.length) {
         this.setClass("filter", "teabag-filtered");
       }
-      return this.setHtml("filter-list", "<li>" + (this.filters.join("</li><li>")) + "</li>", true);
+      return this.setHtml("filter-list", "<li>" + (this.filters.join("</li><li>")), true);
     };
 
     HTML.prototype.reportRunnerStarting = function(runner) {