teabag 0.5.2 → 0.5.3

data/spec/teabag/console_spec.rb

@@ -4,20 +4,21 @@ require "teabag/console"
 describe Teabag::Console do
 
   let(:server) { mock(start: nil, url: "http://url.com") }
+  subject {
+    Teabag::Console.any_instance.stub(:start_server)
+    instance = Teabag::Console.new
+    instance.instance_variable_set(:@server, server)
+    instance
+  }
 
   before do
     subject.instance_variable_set(:@server, server)
-    subject.instance_variable_set(:@suites, [:default, :foo])
+    subject.stub(:suites).and_return([:default, :foo])
     Teabag::Environment.stub(:load)
   end
 
   describe "#initialize" do
 
-    it "loads the environment" do
-      Teabag::Environment.should_receive(:load).once
-      Teabag::Console.new()
-    end
-
     it "assigns @options" do
       options = {foo: "bar"}
       instance = Teabag::Console.new(options)
@@ -30,11 +31,17 @@ describe Teabag::Console do
       expect(instance.instance_variable_get(:@files)).to eql(files)
     end
 
-    it "assigns @suites" do
-      instance = Teabag::Console.new({suite: "foo"})
-      expect(instance.instance_variable_get(:@suites)).to eql(["foo"])
-      instance = Teabag::Console.new()
-      expect(instance.instance_variable_get(:@suites)).to eql(Teabag.configuration.suites.keys)
+    it "loads the environment" do
+      Teabag::Environment.should_receive(:load).once
+      Teabag::Console.new()
+    end
+
+    it "starts the server" do
+      Teabag::Console.any_instance.should_receive(:start_server).and_call_original
+      Teabag::Server.should_receive(:new).and_return(server)
+      server.should_receive(:start)
+      subject.start_server
+      Teabag::Console.new()
     end
 
   end
@@ -43,20 +50,31 @@ describe Teabag::Console do
 
     before do
       STDOUT.stub(:print)
+      subject.stub(:run_specs).and_return(0)
+    end
+
+    it "assigns @options" do
+      options = {foo: "bar"}
+      instance = Teabag::Console.new(options)
+      expect(instance.instance_variable_get(:@options)).to eql(options)
     end
 
-    it "starts the server and calls run" do
-      STDOUT.should_receive(:print).with("Starting server...\n")
-      subject.should_receive(:start_server)
-      STDOUT.should_receive(:print).with("Teabag running default suite at http://url.com/teabag/default...\n")
-      STDOUT.should_receive(:print).with("Teabag running foo suite at http://url.com/teabag/foo...\n")
+    it "assigns @files" do
+      subject.instance_variable_set(:@files, ["file2"])
+      files = ["file1"]
+      subject.execute({}, files)
+      expect(subject.instance_variable_get(:@files)).to eql(files)
+    end
+
+    it "runs the tests" do
+      STDOUT.should_receive(:print).with("Teabag running default suite at http://url.com/teabag/default\n")
+      STDOUT.should_receive(:print).with("Teabag running foo suite at http://url.com/teabag/foo\n")
       subject.should_receive(:run_specs).twice.and_return(2)
       result = subject.execute
       expect(result).to be(true)
     end
 
-    it "starts the server and calls run" do
-      subject.should_receive(:start_server)
+    it "tracks the failure count" do
       subject.should_receive(:run_specs).twice.and_return(0)
       result = subject.execute
       expect(result).to be(false)
@@ -64,16 +82,6 @@ describe Teabag::Console do
 
   end
 
-  describe "#start_server" do
-
-    it "starts the server" do
-      Teabag::Server.should_receive(:new).and_return(server)
-      server.should_receive(:start)
-      subject.start_server
-    end
-
-  end
-
   describe "#run_specs" do
 
     it "calls run_specs on the driver" do

data/spec/teabag/server_spec.rb

@@ -8,6 +8,7 @@ describe Teabag::Server do
 
   before do
     Teabag::Server.any_instance.stub(find_available_port: 31337)
+    STDOUT.stub(:print)
   end
 
   describe "#start" do
@@ -22,6 +23,7 @@ describe Teabag::Server do
     end
 
     it "starts a rack server" do
+      STDOUT.should_receive(:print).with("Starting server...\n")
       server = mock(start: nil)
       Thread.stub(:new) { |&b| @block = b }
 
@@ -33,8 +35,8 @@ describe Teabag::Server do
     end
 
     it "rescues errors" do
-      Thread.should_receive(:new).and_raise("OMG TEABAGGERS!")
-      expect { subject.start }.to raise_error("Cannot start server: OMG TEABAGGERS!")
+      Thread.should_receive(:new).and_raise("OMG!")
+      expect { subject.start }.to raise_error("Cannot start server: OMG!")
     end
 
   end

data/spec/teabag/suite_spec.rb

@@ -10,7 +10,28 @@ describe Teabag::Suite do
     Teabag.configuration.suites = {}
   end
 
-  describe ".new" do
+  describe ".all" do
+
+    it "returns all the suites" do
+      Teabag.configuration.suite(:foo) {}
+      results = Teabag::Suite.all
+      expect(results.first).to be_a(Teabag::Suite)
+      expect(results.length).to be(2)
+    end
+
+  end
+
+  describe ".resolve_spec_for" do
+
+    it "return a hash with the suite name and path" do
+      results = Teabag::Suite.resolve_spec_for("fixture_spec")
+      expect(results[:suite]).to eq("default")
+      expect(results[:path]).to include("base/fixture_spec.")
+    end
+
+  end
+
+  describe "#initialize" do
 
     it "uses default suite configuration" do
       expect(subject.config.helper).to eq("spec_helper")
@@ -105,6 +126,24 @@ describe Teabag::Suite do
 
   end
 
+  describe "#include_spec_for?" do
+
+    it "returns the spec if an exact match was found" do
+      files = subject.send(:glob)
+      expect(subject.include_spec_for?(files.first)).to eq(files.first)
+    end
+
+    it "returns the spec when the file name looks like it could be a match" do
+      files = subject.send(:glob)
+      expect(subject.include_spec_for?('fixture_spec')).to eq(files.first)
+    end
+
+    it "returns false if a matching spec isn't found" do
+      expect(subject.include_spec_for?('_not_a_match_')).to eq(false)
+    end
+
+  end
+
   describe "#specs" do
 
     it "converts file names that are in registered asset paths into usable asset urls" do

data/vendor/assets/javascripts/{mocha-1.7.4.js → mocha-1.8.1.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;