Revert removal of compare nesting

Since we want the user to be able to pass a negative comparison function, the extra layer of wrapping is now needed

spec/core/CustomMatchersSpec.js

@@ -10,8 +10,10 @@ describe("Custom Matchers (Integration)", function() {
     env.it('spec defining a custom matcher', function() {
       env.addMatchers({
         matcherForSpec: function() {
-          return function(actual, expected) {
+          return {
-            return { pass: false, message: "matcherForSpec: actual: " + actual + "; expected: " + expected };
+            compare: function(actual, expected) {
+              return { pass: false, message: "matcherForSpec: actual: " + actual + "; expected: " + expected };
+            }
           }
         }
       });
@@ -38,7 +40,7 @@ describe("Custom Matchers (Integration)", function() {
   it("passes the spec if the custom matcher passes", function(done) {
     env.addMatchers({
       toBeReal: function() {
-        return function() { return { pass: true }; };
+        return { compare: function() { return { pass: true }; } };
       }
     });
 
@@ -57,8 +59,10 @@ describe("Custom Matchers (Integration)", function() {
   it("generates messages with the same rules as built in matchers absent a custom message", function(done) {
     env.addMatchers({
       toBeReal: function() {
-        return function() {
+        return {
-          return { pass: false };
+          compare: function() {
+            return { pass: false };
+          }
         }
       }
     });
@@ -79,7 +83,7 @@ describe("Custom Matchers (Integration)", function() {
     var argumentSpy = jasmine.createSpy("argument spy").and.returnValue({ pass: true });
     env.addMatchers({
       toBeReal: function() {
-        return argumentSpy;
+        return { compare: argumentSpy };
       }
     });
 
@@ -100,7 +104,7 @@ describe("Custom Matchers (Integration)", function() {
   });
 
   it("passes the jasmine utility and current equality matchers to the expectation factory", function(done) {
-    var matcherFactory = function() { return function() { return { pass: true }; }; },
+    var matcherFactory = function() { return { compare: function() { return {pass: true}; }}; },
         argumentSpy = jasmine.createSpy("argument spy").and.returnValue(matcherFactory),
         customEqualityFn = function() { return true; };
 

spec/core/ExpectationSpec.js

@@ -56,7 +56,7 @@ describe("Expectation", function() {
 
   it("wraps matchers's compare functions, passing in matcher dependencies", function() {
     var fakeCompare = function() { return { pass: true }; },
-      matcherFactory = jasmine.createSpy("matcher").and.returnValue(fakeCompare),
+      matcherFactory = jasmine.createSpy("matcher").and.returnValue({ compare: fakeCompare }),
       matchers = {
         toFoo: matcherFactory
       },
@@ -83,7 +83,9 @@ describe("Expectation", function() {
     var fakeCompare = jasmine.createSpy('fake-compare').and.returnValue({pass: true}),
       matchers = {
         toFoo: function() {
-          return fakeCompare;
+          return {
+            compare: fakeCompare
+          };
         }
       },
       util = {
@@ -108,7 +110,9 @@ describe("Expectation", function() {
   it("reports a passing result to the spec when the comparison passes", function() {
     var matchers = {
         toFoo: function() {
-          return function() { return { pass: true }; };
+          return {
+            compare: function() { return { pass: true }; }
+          };
         }
       },
       util = {
@@ -140,7 +144,9 @@ describe("Expectation", function() {
   it("reports a failing result to the spec when the comparison fails", function() {
     var matchers = {
         toFoo: function() {
-          return function() { return { pass: false }; };
+          return {
+            compare: function() { return { pass: false }; }
+          };
         }
       },
       util = {
@@ -172,11 +178,13 @@ describe("Expectation", function() {
   it("reports a failing result and a custom fail message to the spec when the comparison fails", function() {
     var matchers = {
         toFoo: function() {
-          return function() {
+          return {
-            return {
+            compare: function() {
-              pass: false,
+              return {
-              message: "I am a custom message"
+                pass: false,
-            };
+                message: "I am a custom message"
+              };
+            }
           };
         }
       },
@@ -205,7 +213,9 @@ describe("Expectation", function() {
   it("reports a passing result to the spec when the comparison fails for a negative expectation", function() {
     var matchers = {
         toFoo: function() {
-          return function() { return { pass: false }; };
+          return {
+            compare: function() { return { pass: false }; }
+          };
         }
       },
       util = {
@@ -238,7 +248,9 @@ describe("Expectation", function() {
   it("reports a failing result to the spec when the comparison passes for a negative expectation", function() {
     var matchers = {
         toFoo: function() {
-          return function() { return { pass: true }; };
+          return {
+            compare: function() { return { pass: true }; }
+          };
         }
       },
       util = {
@@ -272,11 +284,13 @@ describe("Expectation", function() {
   it("reports a failing result and a custom fail message to the spec when the comparison passes for a negative expectation", function() {
     var matchers = {
         toFoo: function() {
-          return function() {
+          return {
-            return {
+            compare: function() {
-              pass: true,
+              return {
-              message: "I am a custom message"
+                pass: true,
-            };
+                message: "I am a custom message"
+              };
+            }
           };
         }
       },
@@ -303,4 +317,4 @@ describe("Expectation", function() {
       message: "I am a custom message"
     });
   });
-});
+});

spec/core/matchers/toBeCloseToSpec.js

@@ -1,51 +1,51 @@
 describe("toBeCloseTo", function() {
   it("passes when within two decimal places by default", function() {
-    var matcherComparator = j$.matchers.toBeCloseTo(),
+    var matcher = j$.matchers.toBeCloseTo(),
       result;
 
-    result = matcherComparator(0, 0);
+    result = matcher.compare(0, 0);
     expect(result.pass).toBe(true);
 
-    result = matcherComparator(0, 0.001);
+    result = matcher.compare(0, 0.001);
     expect(result.pass).toBe(true);
   });
 
   it("fails when not within two decimal places by default", function() {
-    var matcherComparator = j$.matchers.toBeCloseTo(),
+    var matcher = j$.matchers.toBeCloseTo(),
       result;
 
-    result = matcherComparator(0, 0.01);
+    result = matcher.compare(0, 0.01);
     expect(result.pass).toBe(false);
   });
 
   it("accepts an optional precision argument", function() {
-    var matcherComparator = j$.matchers.toBeCloseTo(),
+    var matcher = j$.matchers.toBeCloseTo(),
       result;
 
-    result = matcherComparator(0, 0.1, 0);
+    result = matcher.compare(0, 0.1, 0);
     expect(result.pass).toBe(true);
 
-    result = matcherComparator(0, 0.0001, 3);
+    result = matcher.compare(0, 0.0001, 3);
     expect(result.pass).toBe(true);
   });
 
   it("rounds expected values", function() {
-    var matcherComparator = j$.matchers.toBeCloseTo(),
+    var matcher = j$.matchers.toBeCloseTo(),
       result;
 
-    result = matcherComparator(1.23, 1.229);
+    result = matcher.compare(1.23, 1.229);
     expect(result.pass).toBe(true);
 
-    result = matcherComparator(1.23, 1.226);
+    result = matcher.compare(1.23, 1.226);
     expect(result.pass).toBe(true);
 
-    result = matcherComparator(1.23, 1.225);
+    result = matcher.compare(1.23, 1.225);
     expect(result.pass).toBe(true);
 
-    result = matcherComparator(1.23, 1.2249999);
+    result = matcher.compare(1.23, 1.2249999);
     expect(result.pass).toBe(false);
 
-    result = matcherComparator(1.23, 1.234);
+    result = matcher.compare(1.23, 1.234);
     expect(result.pass).toBe(true);
   });
 });

spec/core/matchers/toBeDefinedSpec.js

@@ -1,18 +1,18 @@
 describe("toBeDefined", function() {
   it("matches for defined values", function() {
-    var matcherComparator = j$.matchers.toBeDefined(),
+    var matcher = j$.matchers.toBeDefined(),
       result;
 
 
-    result = matcherComparator('foo');
+    result = matcher.compare('foo');
     expect(result.pass).toBe(true);
   });
 
   it("fails when matching undefined values", function() {
-    var matcherComparator = j$.matchers.toBeDefined(),
+    var matcher = j$.matchers.toBeDefined(),
       result;
 
-    result = matcherComparator(void 0);
+    result = matcher.compare(void 0);
     expect(result.pass).toBe(false);
   })
 });

spec/core/matchers/toBeFalsySpec.js

@@ -1,38 +1,38 @@
 describe("toBeFalsy", function() {
   it("passes for 'falsy' values", function() {
-    var matcherComparator = j$.matchers.toBeFalsy(),
+    var matcher = j$.matchers.toBeFalsy(),
       result;
 
-    result = matcherComparator(false);
+    result = matcher.compare(false);
     expect(result.pass).toBe(true);
 
-    result = matcherComparator(0);
+    result = matcher.compare(0);
     expect(result.pass).toBe(true);
 
-    result = matcherComparator('');
+    result = matcher.compare('');
     expect(result.pass).toBe(true);
 
-    result = matcherComparator(null);
+    result = matcher.compare(null);
     expect(result.pass).toBe(true);
 
-    result = matcherComparator(void 0);
+    result = matcher.compare(void 0);
     expect(result.pass).toBe(true);
   });
 
   it("fails for 'truthy' values", function() {
-    var matcherComparator = j$.matchers.toBeFalsy(),
+    var matcher = j$.matchers.toBeFalsy(),
       result;
 
-    result = matcherComparator(true);
+    result = matcher.compare(true);
     expect(result.pass).toBe(false);
 
-    result = matcherComparator(1);
+    result = matcher.compare(1);
     expect(result.pass).toBe(false);
 
-    result = matcherComparator("foo");
+    result = matcher.compare("foo");
     expect(result.pass).toBe(false);
 
-    result = matcherComparator({});
+    result = matcher.compare({});
     expect(result.pass).toBe(false);
   });
 });

spec/core/matchers/toBeGreaterThanSpec.js

@@ -1,19 +1,19 @@
 describe("toBeGreaterThan", function() {
   it("passes when actual > expected", function() {
-    var matcherComparator = j$.matchers.toBeGreaterThan(),
+    var matcher = j$.matchers.toBeGreaterThan(),
       result;
 
-    result = matcherComparator(2, 1);
+    result = matcher.compare(2, 1);
     expect(result.pass).toBe(true);
   });
 
   it("fails when actual <= expected", function() {
-    var matcherComparator = j$.matchers.toBeGreaterThan();
+    var matcher = j$.matchers.toBeGreaterThan();
 
-    result = matcherComparator(1, 1);
+    result = matcher.compare(1, 1);
     expect(result.pass).toBe(false);
 
-    result = matcherComparator(1, 2);
+    result = matcher.compare(1, 2);
     expect(result.pass).toBe(false);
   });
 });

spec/core/matchers/toBeLessThanSpec.js

@@ -1,20 +1,20 @@
 describe("toBeLessThan", function() {
   it("passes when actual < expected", function() {
-    var matcherComparator = j$.matchers.toBeLessThan(),
+    var matcher = j$.matchers.toBeLessThan(),
       result;
 
-    result = matcherComparator(1, 2);
+    result = matcher.compare(1, 2);
     expect(result.pass).toBe(true);
   });
 
   it("fails when actual <= expected", function() {
-    var matcherComparator = j$.matchers.toBeLessThan(),
+    var matcher = j$.matchers.toBeLessThan(),
       result;
 
-    result = matcherComparator(1, 1);
+    result = matcher.compare(1, 1);
     expect(result.pass).toBe(false);
 
-    result = matcherComparator(2, 1);
+    result = matcher.compare(2, 1);
     expect(result.pass).toBe(false);
   });
 });

spec/core/matchers/toBeNaNSpec.js

@@ -1,35 +1,35 @@
 describe("toBeNaN", function() {
   it("passes for NaN with a custom .not fail", function() {
-    var matcherComparator = j$.matchers.toBeNaN(),
+    var matcher = j$.matchers.toBeNaN(),
       result;
 
-    result = matcherComparator(Number.NaN);
+    result = matcher.compare(Number.NaN);
     expect(result.pass).toBe(true);
     expect(result.message).toEqual("Expected actual not to be NaN.");
   });
 
   it("fails for anything not a NaN", function() {
-    var matcherComparator = j$.matchers.toBeNaN();
+    var matcher = j$.matchers.toBeNaN();
 
-    result = matcherComparator(1);
+    result = matcher.compare(1);
     expect(result.pass).toBe(false);
 
-    result = matcherComparator(null);
+    result = matcher.compare(null);
     expect(result.pass).toBe(false);
 
-    result = matcherComparator(void 0);
+    result = matcher.compare(void 0);
     expect(result.pass).toBe(false);
 
-    result = matcherComparator('');
+    result = matcher.compare('');
     expect(result.pass).toBe(false);
 
-    result = matcherComparator(Number.POSITIVE_INFINITY);
+    result = matcher.compare(Number.POSITIVE_INFINITY);
     expect(result.pass).toBe(false);
   });
 
   it("has a custom message on failure", function() {
-    var matcherComparator = j$.matchers.toBeNaN(),
+    var matcher = j$.matchers.toBeNaN(),
-      result = matcherComparator(0);
+      result = matcher.compare(0);
 
     expect(result.message).toEqual("Expected 0 to be NaN.");
   });

spec/core/matchers/toBeNullSpec.js

@@ -1,17 +1,17 @@
 describe("toBeNull", function() {
   it("passes for null", function() {
-    var matcherComparator = j$.matchers.toBeNull(),
+    var matcher = j$.matchers.toBeNull(),
       result;
 
-    result = matcherComparator(null);
+    result = matcher.compare(null);
     expect(result.pass).toBe(true);
   });
 
   it("fails for non-null", function() {
-    var matcherComparator = j$.matchers.toBeNull(),
+    var matcher = j$.matchers.toBeNull(),
       result;
 
-    result = matcherComparator('foo');
+    result = matcher.compare('foo');
     expect(result.pass).toBe(false);
   });
 });

spec/core/matchers/toBeSpec.js

@@ -1,17 +1,17 @@
 describe("toBe", function() {
   it("passes when actual === expected", function() {
-    var matcherComparator = j$.matchers.toBe(),
+    var matcher = j$.matchers.toBe(),
       result;
 
-    result = matcherComparator(1, 1);
+    result = matcher.compare(1, 1);
     expect(result.pass).toBe(true);
   });
 
   it("fails when actual !== expected", function() {
-    var matcherComparator = j$.matchers.toBe(),
+    var matcher = j$.matchers.toBe(),
       result;
 
-    result = matcherComparator(1, 2);
+    result = matcher.compare(1, 2);
     expect(result.pass).toBe(false);
   });
 });

spec/core/matchers/toBeTruthySpec.js

@@ -1,38 +1,38 @@
 describe("toBeTruthy", function() {
   it("passes for 'truthy' values", function() {
-    var matcherComparator = j$.matchers.toBeTruthy(),
+    var matcher = j$.matchers.toBeTruthy(),
       result;
 
-    result = matcherComparator(true);
+    result = matcher.compare(true);
     expect(result.pass).toBe(true);
 
-    result = matcherComparator(1);
+    result = matcher.compare(1);
     expect(result.pass).toBe(true);
 
-    result = matcherComparator("foo");
+    result = matcher.compare("foo");
     expect(result.pass).toBe(true);
 
-    result = matcherComparator({});
+    result = matcher.compare({});
     expect(result.pass).toBe(true);
   });
 
   it("fails for 'falsy' values", function() {
-    var matcherComparator = j$.matchers.toBeTruthy(),
+    var matcher = j$.matchers.toBeTruthy(),
       result;
 
-    result = matcherComparator(false);
+    result = matcher.compare(false);
     expect(result.pass).toBe(false);
 
-    result = matcherComparator(0);
+    result = matcher.compare(0);
     expect(result.pass).toBe(false);
 
-    result = matcherComparator('');
+    result = matcher.compare('');
     expect(result.pass).toBe(false);
 
-    result = matcherComparator(null);
+    result = matcher.compare(null);
     expect(result.pass).toBe(false);
 
-    result = matcherComparator(void 0);
+    result = matcher.compare(void 0);
     expect(result.pass).toBe(false);
   });
 });

spec/core/matchers/toBeUndefinedSpec.js

@@ -1,17 +1,17 @@
 describe("toBeUndefined", function() {
   it("passes for undefined values", function() {
-    var matcherComparator = j$.matchers.toBeUndefined(),
+    var matcher = j$.matchers.toBeUndefined(),
       result;
 
-    result = matcherComparator(void 0);
+    result = matcher.compare(void 0);
     expect(result.pass).toBe(true);
 
   });
 
   it("fails when matching defined values", function() {
-    var matcherComparator = j$.matchers.toBeUndefined();
+    var matcher = j$.matchers.toBeUndefined();
 
-    result = matcherComparator('foo');
+    result = matcher.compare('foo');
     expect(result.pass).toBe(false);
   })
 });

spec/core/matchers/toContainSpec.js

@@ -3,9 +3,9 @@ describe("toContain", function() {
     var util = {
         contains: jasmine.createSpy('delegated-contains').and.returnValue(true)
       },
-      matcherComparator = j$.matchers.toContain(util);
+      matcher = j$.matchers.toContain(util);
 
-    result = matcherComparator("ABC", "B");
+    result = matcher.compare("ABC", "B");
     expect(util.contains).toHaveBeenCalledWith("ABC", "B", []);
     expect(result.pass).toBe(true);
   });
@@ -15,9 +15,9 @@ describe("toContain", function() {
         contains: jasmine.createSpy('delegated-contains').and.returnValue(true)
       },
       customEqualityTesters = ['a', 'b'],
-      matcherComparator = j$.matchers.toContain(util, customEqualityTesters);
+      matcher = j$.matchers.toContain(util, customEqualityTesters);
 
-    result = matcherComparator("ABC", "B");
+    result = matcher.compare("ABC", "B");
     expect(util.contains).toHaveBeenCalledWith("ABC", "B", ['a', 'b']);
     expect(result.pass).toBe(true);
   });

spec/core/matchers/toEqualSpec.js

@@ -3,10 +3,10 @@ describe("toEqual", function() {
     var util = {
         equals: jasmine.createSpy('delegated-equals').and.returnValue(true)
       },
-      matcherComparator = j$.matchers.toEqual(util),
+      matcher = j$.matchers.toEqual(util),
       result;
 
-    result = matcherComparator(1, 1);
+    result = matcher.compare(1, 1);
 
     expect(util.equals).toHaveBeenCalledWith(1, 1, []);
     expect(result.pass).toBe(true);
@@ -17,10 +17,10 @@ describe("toEqual", function() {
         equals: jasmine.createSpy('delegated-equals').and.returnValue(true)
       },
       customEqualityTesters = ['a', 'b'],
-      matcherComparator = j$.matchers.toEqual(util, customEqualityTesters),
+      matcher = j$.matchers.toEqual(util, customEqualityTesters),
       result;
 
-    result = matcherComparator(1, 1);
+    result = matcher.compare(1, 1);
 
     expect(util.equals).toHaveBeenCalledWith(1, 1, ['a', 'b']);
     expect(result.pass).toBe(true);

spec/core/matchers/toHaveBeenCalledSpec.js

@@ -1,44 +1,44 @@
 describe("toHaveBeenCalled", function() {
   it("passes when the actual was called, with a custom .not fail message", function() {
-    var matcherComparator = j$.matchers.toHaveBeenCalled(),
+    var matcher = j$.matchers.toHaveBeenCalled(),
       calledSpy = j$.createSpy('called-spy'),
       result;
 
     calledSpy();
 
-    result = matcherComparator(calledSpy);
+    result = matcher.compare(calledSpy);
     expect(result.pass).toBe(true);
     expect(result.message).toEqual("Expected spy called-spy not to have been called.");
   });
 
   it("fails when the actual was not called", function() {
-    var matcherComparator = j$.matchers.toHaveBeenCalled(),
+    var matcher = j$.matchers.toHaveBeenCalled(),
       uncalledSpy = j$.createSpy('uncalled spy');
 
-    result = matcherComparator(uncalledSpy);
+    result = matcher.compare(uncalledSpy);
     expect(result.pass).toBe(false);
   });
 
   it("throws an exception when the actual is not a spy", function() {
-    var matcherComparator = j$.matchers.toHaveBeenCalled(),
+    var matcher = j$.matchers.toHaveBeenCalled(),
       fn = function() {};
 
-    expect(function() { matcherComparator(fn) }).toThrow(new Error("Expected a spy, but got Function."));
+    expect(function() { matcher.compare(fn) }).toThrow(new Error("Expected a spy, but got Function."));
   });
 
   it("throws an exception when invoked with any arguments", function() {
-    var matcherComparator = j$.matchers.toHaveBeenCalled(),
+    var matcher = j$.matchers.toHaveBeenCalled(),
       spy = j$.createSpy('sample spy');
 
-    expect(function() { matcherComparator(spy, 'foo') }).toThrow(new Error("toHaveBeenCalled does not take arguments, use toHaveBeenCalledWith"));
+    expect(function() { matcher.compare(spy, 'foo') }).toThrow(new Error("toHaveBeenCalled does not take arguments, use toHaveBeenCalledWith"));
   });
 
   it("has a custom message on failure", function() {
-    var matcherComparator = j$.matchers.toHaveBeenCalled(),
+    var matcher = j$.matchers.toHaveBeenCalled(),
       spy = j$.createSpy('sample-spy'),
       result;
 
-    result = matcherComparator(spy);
+    result = matcher.compare(spy);
 
     expect(result.message).toEqual("Expected spy sample-spy to have been called.");
   });

spec/core/matchers/toHaveBeenCalledWithSpec.js

@@ -3,12 +3,12 @@ describe("toHaveBeenCalledWith", function() {
     var util = {
           contains: jasmine.createSpy('delegated-contains').and.returnValue(true)
         },
-        matcherComparator = j$.matchers.toHaveBeenCalledWith(util),
+        matcher = j$.matchers.toHaveBeenCalledWith(util),
         calledSpy = j$.createSpy('called-spy'),
         result;
 
     calledSpy('a', 'b');
-    result = matcherComparator(calledSpy, 'a', 'b');
+    result = matcher.compare(calledSpy, 'a', 'b');
 
     expect(result.pass).toBe(true);
     expect(result.message).toEqual("Expected spy called-spy not to have been called with [ 'a', 'b' ] but it was.");
@@ -18,11 +18,11 @@ describe("toHaveBeenCalledWith", function() {
     var util = {
           contains: jasmine.createSpy('delegated-contains').and.returnValue(false)
         },
-        matcherComparator = j$.matchers.toHaveBeenCalledWith(util),
+        matcher = j$.matchers.toHaveBeenCalledWith(util),
         uncalledSpy = j$.createSpy('uncalled spy'),
         result;
 
-    result = matcherComparator(uncalledSpy);
+    result = matcher.compare(uncalledSpy);
     expect(result.pass).toBe(false);
     expect(result.message).toEqual("Expected spy uncalled spy to have been called with [  ] but it was never called.");
   });
@@ -31,22 +31,22 @@ describe("toHaveBeenCalledWith", function() {
     var util = {
           contains: jasmine.createSpy('delegated-contains').and.returnValue(false)
         },
-        matcherComparator = j$.matchers.toHaveBeenCalledWith(util),
+        matcher = j$.matchers.toHaveBeenCalledWith(util),
         calledSpy = j$.createSpy('called spy'),
         result;
 
     calledSpy('a');
     calledSpy('c', 'd');
-    result = matcherComparator(calledSpy, 'a', 'b');
+    result = matcher.compare(calledSpy, 'a', 'b');
 
     expect(result.pass).toBe(false);
     expect(result.message).toEqual("Expected spy called spy to have been called with [ 'a', 'b' ] but actual calls were [ 'a' ], [ 'c', 'd' ].");
   });
 
   it("throws an exception when the actual is not a spy", function() {
-    var matcherComparator = j$.matchers.toHaveBeenCalledWith(),
+    var matcher = j$.matchers.toHaveBeenCalledWith(),
         fn = function() {};
 
-    expect(function() { matcherComparator(fn) }).toThrow(new Error("Expected a spy, but got Function."));
+    expect(function() { matcher.compare(fn) }).toThrow(new Error("Expected a spy, but got Function."));
   });
 });

spec/core/matchers/toMatchSpec.js

@@ -1,33 +1,33 @@
 describe("toMatch", function() {
   it("passes when RegExps are equivalent", function() {
-    var matcherComparator = j$.matchers.toMatch(),
+    var matcher = j$.matchers.toMatch(),
       result;
 
-    result = matcherComparator(/foo/, /foo/);
+    result = matcher.compare(/foo/, /foo/);
     expect(result.pass).toBe(true);
   });
 
   it("fails when RegExps are not equivalent", function() {
-    var matcherComparator = j$.matchers.toMatch(),
+    var matcher = j$.matchers.toMatch(),
       result;
 
-    result = matcherComparator(/bar/, /foo/);
+    result = matcher.compare(/bar/, /foo/);
     expect(result.pass).toBe(false);
   });
 
   it("passes when the actual matches the expected string as a pattern", function() {
-    var matcherComparator = j$.matchers.toMatch(),
+    var matcher = j$.matchers.toMatch(),
       result;
 
-    result = matcherComparator('foosball', 'foo');
+    result = matcher.compare('foosball', 'foo');
     expect(result.pass).toBe(true);
   });
 
   it("fails when the actual matches the expected string as a pattern", function() {
-    var matcherComparator = j$.matchers.toMatch(),
+    var matcher = j$.matchers.toMatch(),
       result;
 
-    result = matcherComparator('bar', 'foo');
+    result = matcher.compare('bar', 'foo');
     expect(result.pass).toBe(false);
   });
 });

spec/core/matchers/toThrowErrorSpec.js

@@ -1,142 +1,142 @@
 describe("toThrowError", function() {
   it("throws an error when the actual is not a function", function() {
-    var matcherComparator = j$.matchers.toThrowError();
+    var matcher = j$.matchers.toThrowError();
 
     expect(function() {
-      matcherComparator({});
+      matcher.compare({});
     }).toThrowError("Actual is not a Function");
   });
 
   it("throws an error when the expected is not an Error, string, or RegExp", function() {
-    var matcherComparator = j$.matchers.toThrowError(),
+    var matcher = j$.matchers.toThrowError(),
       fn = function() {
         throw new Error("foo");
       };
 
     expect(function() {
-      matcherComparator(fn, 1);
+      matcher.compare(fn, 1);
     }).toThrowError("Expected is not an Error, string, or RegExp.");
   });
 
   it("throws an error when the expected error type is not an Error", function() {
-    var matcherComparator = j$.matchers.toThrowError(),
+    var matcher = j$.matchers.toThrowError(),
       fn = function() {
         throw new Error("foo");
       };
 
     expect(function() {
-      matcherComparator(fn, void 0, "foo");
+      matcher.compare(fn, void 0, "foo");
     }).toThrowError("Expected error type is not an Error.");
   });
 
   it("throws an error when the expected error message is not a string or RegExp", function() {
-    var matcherComparator = j$.matchers.toThrowError(),
+    var matcher = j$.matchers.toThrowError(),
       fn = function() {
         throw new Error("foo");
       };
 
     expect(function() {
-      matcherComparator(fn, Error, 1);
+      matcher.compare(fn, Error, 1);
     }).toThrowError("Expected error message is not a string or RegExp.");
   });
 
   it("fails if actual does not throw at all", function() {
-    var matcherComparator = j$.matchers.toThrowError(),
+    var matcher = j$.matchers.toThrowError(),
       fn = function() {
         return true;
       },
       result;
 
-    result = matcherComparator(fn);
+    result = matcher.compare(fn);
 
     expect(result.pass).toBe(false);
     expect(result.message).toEqual("Expected function to throw an Error.");
   });
 
   it("fails if thrown is not an instanceof Error", function() {
-    var matcherComparator = j$.matchers.toThrowError(),
+    var matcher = j$.matchers.toThrowError(),
       fn = function() {
         throw 4;
       },
       result;
 
-    result = matcherComparator(fn);
+    result = matcher.compare(fn);
     expect(result.pass).toBe(false);
     expect(result.message).toEqual("Expected function to throw an Error, but it threw 4.");
   });
 
   it("fails with the correct message if thrown is a falsy value", function() {
-    var matcherComparator = j$.matchers.toThrowError(),
+    var matcher = j$.matchers.toThrowError(),
       fn = function() {
         throw undefined;
       },
       result;
 
-    result = matcherComparator(fn);
+    result = matcher.compare(fn);
     expect(result.pass).toBe(false);
     expect(result.message).toEqual("Expected function to throw an Error, but it threw undefined.");
   });
 
   it("passes if thrown is a type of Error, but there is no expected error", function() {
-    var matcherComparator = j$.matchers.toThrowError(),
+    var matcher = j$.matchers.toThrowError(),
       fn = function() {
         throw new TypeError();
       },
       result;
 
-    result = matcherComparator(fn);
+    result = matcher.compare(fn);
 
     expect(result.pass).toBe(true);
     expect(result.message).toEqual("Expected function not to throw an Error, but it threw TypeError.");
   });
 
   it("passes if thrown is an Error and the expected is the same message", function() {
-    var matcherComparator = j$.matchers.toThrowError(),
+    var matcher = j$.matchers.toThrowError(),
       fn = function() {
         throw new Error("foo");
       },
       result;
 
-    result = matcherComparator(fn, "foo");
+    result = matcher.compare(fn, "foo");
 
     expect(result.pass).toBe(true);
     expect(result.message).toEqual("Expected function not to throw an exception with message 'foo'.");
   });
 
   it("fails if thrown is an Error and the expected is not the same message", function() {
-    var matcherComparator = j$.matchers.toThrowError(),
+    var matcher = j$.matchers.toThrowError(),
       fn = function() {
         throw new Error("foo");
       },
       result;
 
-    result = matcherComparator(fn, "bar");
+    result = matcher.compare(fn, "bar");
 
     expect(result.pass).toBe(false);
     expect(result.message).toEqual("Expected function to throw an exception with message 'bar', but it threw an exception with message 'foo'.");
   });
 
   it("passes if thrown is an Error and the expected is a RegExp that matches the message", function() {
-    var matcherComparator = j$.matchers.toThrowError(),
+    var matcher = j$.matchers.toThrowError(),
       fn = function() {
         throw new Error("a long message");
       },
       result;
 
-    result = matcherComparator(fn, /long/);
+    result = matcher.compare(fn, /long/);
 
     expect(result.pass).toBe(true);
     expect(result.message).toEqual("Expected function not to throw an exception with a message matching /long/.");
   });
 
   it("fails if thrown is an Error and the expected is a RegExp that does not match the message", function() {
-    var matcherComparator = j$.matchers.toThrowError(),
+    var matcher = j$.matchers.toThrowError(),
       fn = function() {
         throw new Error("a long message");
       },
       result;
 
-    result = matcherComparator(fn, /foo/);
+    result = matcher.compare(fn, /foo/);
 
     expect(result.pass).toBe(false);
     expect(result.message).toEqual("Expected function to throw an exception with a message matching /foo/, but it threw an exception with message 'a long message'.");
@@ -146,13 +146,13 @@ describe("toThrowError", function() {
     var util = {
         equals: jasmine.createSpy('delegated-equal').and.returnValue(true)
       },
-      matcherComparator = j$.matchers.toThrowError(util),
+      matcher = j$.matchers.toThrowError(util),
       fn = function() {
         throw new Error();
       },
       result;
 
-    result = matcherComparator(fn, Error);
+    result = matcher.compare(fn, Error);
 
     expect(result.pass).toBe(true);
     expect(result.message).toEqual("Expected function not to throw Error.");
@@ -162,7 +162,7 @@ describe("toThrowError", function() {
     var util = {
         equals: jasmine.createSpy('delegated-equal').and.returnValue(true)
       },
-      matcherComparator = j$.matchers.toThrowError(util),
+      matcher = j$.matchers.toThrowError(util),
       CustomError = function CustomError(arg) { arg.x },
       fn = function() {
         throw new CustomError({ x: 1 });
@@ -172,7 +172,7 @@ describe("toThrowError", function() {
     CustomError.prototype = new Error();
     CustomError.prototype.constructor = CustomError;
 
-    result = matcherComparator(fn, CustomError);
+    result = matcher.compare(fn, CustomError);
 
     expect(result.pass).toBe(true);
     expect(result.message).toEqual("Expected function not to throw CustomError.");
@@ -182,13 +182,13 @@ describe("toThrowError", function() {
     var util = {
         equals: jasmine.createSpy('delegated-equal').and.returnValue(false)
       },
-      matcherComparator = j$.matchers.toThrowError(util),
+      matcher = j$.matchers.toThrowError(util),
       fn = function() {
         throw new Error();
       },
       result;
 
-    result = matcherComparator(fn, TypeError);
+    result = matcher.compare(fn, TypeError);
 
     expect(result.pass).toBe(false);
     expect(result.message).toEqual("Expected function to throw TypeError, but it threw Error.");
@@ -198,13 +198,13 @@ describe("toThrowError", function() {
     var util = {
         equals: jasmine.createSpy('delegated-equal').and.returnValue(true)
       },
-      matcherComparator = j$.matchers.toThrowError(util),
+      matcher = j$.matchers.toThrowError(util),
       fn = function() {
         throw new TypeError("foo");
       },
       result;
 
-    result = matcherComparator(fn, TypeError, "foo");
+    result = matcher.compare(fn, TypeError, "foo");
 
     expect(result.pass).toBe(true);
     expect(result.message).toEqual("Expected function not to throw TypeError with message \"foo\".");
@@ -214,7 +214,7 @@ describe("toThrowError", function() {
     var util = {
         equals: jasmine.createSpy('delegated-equal').and.returnValue(true)
       },
-      matcherComparator = j$.matchers.toThrowError(util),
+      matcher = j$.matchers.toThrowError(util),
       CustomError = function CustomError(arg) { this.message = arg.message },
       fn = function() {
         throw new CustomError({message: "foo"});
@@ -224,7 +224,7 @@ describe("toThrowError", function() {
     CustomError.prototype = new Error();
     CustomError.prototype.constructor = CustomError;
 
-    result = matcherComparator(fn, CustomError, "foo");
+    result = matcher.compare(fn, CustomError, "foo");
 
     expect(result.pass).toBe(true);
     expect(result.message).toEqual("Expected function not to throw CustomError with message \"foo\".");
@@ -234,13 +234,13 @@ describe("toThrowError", function() {
     var util = {
         equals: jasmine.createSpy('delegated-equal').and.returnValue(false)
       },
-      matcherComparator = j$.matchers.toThrowError(util),
+      matcher = j$.matchers.toThrowError(util),
       fn = function() {
         throw new TypeError("foo");
       },
       result;
 
-    result = matcherComparator(fn, TypeError, "bar");
+    result = matcher.compare(fn, TypeError, "bar");
 
     expect(result.pass).toBe(false);
     expect(result.message).toEqual("Expected function to throw TypeError with message \"bar\", but it threw TypeError with message \"foo\".");
@@ -250,13 +250,13 @@ describe("toThrowError", function() {
     var util = {
         equals: jasmine.createSpy('delegated-equal').and.returnValue(true)
       },
-      matcherComparator = j$.matchers.toThrowError(util),
+      matcher = j$.matchers.toThrowError(util),
       fn = function() {
         throw new TypeError("foo");
       },
       result;
 
-    result = matcherComparator(fn, TypeError, /foo/);
+    result = matcher.compare(fn, TypeError, /foo/);
 
     expect(result.pass).toBe(true);
     expect(result.message).toEqual("Expected function not to throw TypeError with message matching /foo/.");
@@ -266,13 +266,13 @@ describe("toThrowError", function() {
     var util = {
         equals: jasmine.createSpy('delegated-equal').and.returnValue(false)
       },
-      matcherComparator = j$.matchers.toThrowError(util),
+      matcher = j$.matchers.toThrowError(util),
       fn = function() {
         throw new TypeError("foo");
       },
       result;
 
-    result = matcherComparator(fn, TypeError, /bar/);
+    result = matcher.compare(fn, TypeError, /bar/);
 
     expect(result.pass).toBe(false);
     expect(result.message).toEqual("Expected function to throw TypeError with message matching /bar/, but it threw TypeError with message \"foo\".");

spec/core/matchers/toThrowSpec.js

@@ -1,20 +1,21 @@
 describe("toThrow", function() {
   it("throws an error when the actual is not a function", function() {
-    var matcherComparator = j$.matchers.toThrow();
+    var matcher = j$.matchers.toThrow();
 
     expect(function() {
+      matcher.compare({});
       matcherComparator({});
     }).toThrowError("Actual is not a Function");
   });
 
   it("fails if actual does not throw", function() {
-    var matcherComparator = j$.matchers.toThrow(),
+    var matcher = j$.matchers.toThrow(),
       fn = function() {
         return true;
       },
       result;
 
-    result = matcherComparator(fn);
+    result = matcher.compare(fn);
 
     expect(result.pass).toBe(false);
     expect(result.message).toEqual("Expected function to throw an exception.");
@@ -24,26 +25,26 @@ describe("toThrow", function() {
     var util = {
         equals: jasmine.createSpy('delegated-equal').and.returnValue(true)
       },
-      matcherComparator = j$.matchers.toThrow(util),
+      matcher = j$.matchers.toThrow(util),
       fn = function() {
         throw 5;
       },
       result;
 
-    result = matcherComparator(fn);
+    result = matcher.compare(fn);
 
     expect(result.pass).toBe(true);
     expect(result.message).toEqual("Expected function not to throw, but it threw 5.");
   });
 
   it("passes even if what is thrown is falsy", function() {
-    var matcherComparator = j$.matchers.toThrow(),
+    var matcher = j$.matchers.toThrow(),
       fn = function() {
         throw undefined;
       },
       result;
 
-    result = matcherComparator(fn);
+    result = matcher.compare(fn);
     expect(result.pass).toBe(true);
     expect(result.message).toEqual("Expected function not to throw, but it threw undefined.");
   });
@@ -52,13 +53,13 @@ describe("toThrow", function() {
     var util = {
         equals: jasmine.createSpy('delegated-equal').and.returnValue(true)
       },
-      matcherComparator = j$.matchers.toThrow(util),
+      matcher = j$.matchers.toThrow(util),
       fn = function() {
         throw 5;
       },
       result;
 
-    result = matcherComparator(fn, 5);
+    result = matcher.compare(fn, 5);
 
     expect(result.pass).toBe(true);
     expect(result.message).toEqual("Expected function not to throw 5.");
@@ -68,13 +69,13 @@ describe("toThrow", function() {
     var util = {
         equals: jasmine.createSpy('delegated-equal').and.returnValue(false)
       },
-      matcherComparator = j$.matchers.toThrow(util),
+      matcher = j$.matchers.toThrow(util),
       fn = function() {
         throw 5;
       },
       result;
 
-    result = matcherComparator(fn, "foo");
+    result = matcher.compare(fn, "foo");
 
     expect(result.pass).toBe(false);
     expect(result.message).toEqual("Expected function to throw 'foo', but it threw 5.");
@@ -84,13 +85,13 @@ describe("toThrow", function() {
     var util = {
         equals: jasmine.createSpy('delegated-equal').and.returnValue(false)
       },
-      matcherComparator = j$.matchers.toThrow(util),
+      matcher = j$.matchers.toThrow(util),
       fn = function() {
         throw 5;
       },
       result;
 
-    result = matcherComparator(fn, void 0);
+    result = matcher.compare(fn, void 0);
 
     expect(result.pass).toBe(false);
     expect(result.message).toEqual("Expected function to throw undefined, but it threw 5.");

src/core/Expectation.js

@@ -22,8 +22,7 @@ getJasmineRequireObj().Expectation = function() {
 
       args.unshift(this.actual);
 
-      var matcherComparator = matcherFactory(this.util, this.customEqualityTesters),
+      var result = matcherFactory(this.util, this.customEqualityTesters).compare.apply(null, args);
-          result = matcherComparator.apply(null, args);
 
       if (this.isNot) {
         result.pass = !result.pass;

src/core/matchers/toBe.js

@@ -1,9 +1,11 @@
 getJasmineRequireObj().toBe = function() {
   function toBe() {
-    return function(actual, expected) {
+    return {
-      return {
+      compare: function(actual, expected) {
-        pass: actual === expected
+        return {
-      };
+          pass: actual === expected
+        };
+      }
     };
   }
 

src/core/matchers/toBeCloseTo.js

@@ -1,14 +1,16 @@
 getJasmineRequireObj().toBeCloseTo = function() {
 
   function toBeCloseTo() {
-    return function(actual, expected, precision) {
+    return {
-      if (precision !== 0) {
+      compare: function(actual, expected, precision) {
-        precision = precision || 2;
+        if (precision !== 0) {
-      }
+          precision = precision || 2;
+        }
 
-      return {
+        return {
-        pass: Math.abs(expected - actual) < (Math.pow(10, -precision) / 2)
+          pass: Math.abs(expected - actual) < (Math.pow(10, -precision) / 2)
-      };
+        };
+      }
     };
   }
 

src/core/matchers/toBeDefined.js

@@ -1,9 +1,11 @@
 getJasmineRequireObj().toBeDefined = function() {
   function toBeDefined() {
-    return function(actual) {
+    return {
-      return {
+      compare: function(actual) {
-        pass: (void 0 !== actual)
+        return {
-      };
+          pass: (void 0 !== actual)
+        };
+      }
     };
   }
 

src/core/matchers/toBeFalsy.js

@@ -1,9 +1,11 @@
 getJasmineRequireObj().toBeFalsy = function() {
   function toBeFalsy() {
-    return function(actual) {
+    return {
-      return {
+      compare: function(actual) {
-        pass: !!!actual
+        return {
-      };
+          pass: !!!actual
+        };
+      }
     };
   }
 

src/core/matchers/toBeGreaterThan.js

@@ -1,10 +1,12 @@
 getJasmineRequireObj().toBeGreaterThan = function() {
 
   function toBeGreaterThan() {
-    return function(actual, expected) {
+    return {
-      return {
+      compare: function(actual, expected) {
-        pass: actual > expected
+        return {
-      };
+          pass: actual > expected
+        };
+      }
     };
   }
 

src/core/matchers/toBeLessThan.js

@@ -1,11 +1,14 @@
 getJasmineRequireObj().toBeLessThan = function() {
   function toBeLessThan() {
-    return function(actual, expected) {
+    return {
-      return {
+
-        pass: actual < expected
+      compare: function(actual, expected) {
-      };
+        return {
+          pass: actual < expected
+        };
+      }
     };
   }
 
   return toBeLessThan;
-};
+};

src/core/matchers/toBeNaN.js

@@ -1,18 +1,20 @@
 getJasmineRequireObj().toBeNaN = function(j$) {
 
   function toBeNaN() {
-    return function(actual) {
+    return {
-      var result = {
+      compare: function(actual) {
-        pass: (actual !== actual)
+        var result = {
-      };
+          pass: (actual !== actual)
+        };
 
-      if (result.pass) {
+        if (result.pass) {
-        result.message = "Expected actual not to be NaN.";
+          result.message = "Expected actual not to be NaN.";
-      } else {
+        } else {
-        result.message = "Expected " + j$.pp(actual) + " to be NaN.";
+          result.message = "Expected " + j$.pp(actual) + " to be NaN.";
+        }
+
+        return result;
       }
-
-      return result;
     };
   }
 

src/core/matchers/toBeNull.js

@@ -1,10 +1,12 @@
 getJasmineRequireObj().toBeNull = function() {
 
   function toBeNull() {
-    return function(actual) {
+    return {
-      return {
+      compare: function(actual) {
-        pass: actual === null
+        return {
-      };
+          pass: actual === null
+        };
+      }
     };
   }
 

src/core/matchers/toBeTruthy.js

@@ -1,10 +1,12 @@
 getJasmineRequireObj().toBeTruthy = function() {
 
   function toBeTruthy() {
-    return function(actual) {
+    return {
-      return {
+      compare: function(actual) {
-        pass: !!actual
+        return {
-      };
+          pass: !!actual
+        };
+      }
     };
   }
 

src/core/matchers/toBeUndefined.js

@@ -1,10 +1,12 @@
 getJasmineRequireObj().toBeUndefined = function() {
 
   function toBeUndefined() {
-    return function(actual) {
+    return {
-      return {
+      compare: function(actual) {
-        pass: void 0 === actual
+        return {
-      };
+          pass: void 0 === actual
+        };
+      }
     };
   }
 

src/core/matchers/toContain.js

@@ -2,10 +2,13 @@ getJasmineRequireObj().toContain = function() {
   function toContain(util, customEqualityTesters) {
     customEqualityTesters = customEqualityTesters || [];
 
-    return function(actual, expected) {
+    return {
-      return {
+      compare: function(actual, expected) {
-        pass: util.contains(actual, expected, customEqualityTesters)
+
-      };
+        return {
+          pass: util.contains(actual, expected, customEqualityTesters)
+        };
+      }
     };
   }
 

src/core/matchers/toEqual.js

@@ -3,10 +3,16 @@ getJasmineRequireObj().toEqual = function() {
   function toEqual(util, customEqualityTesters) {
     customEqualityTesters = customEqualityTesters || [];
 
-    return function(actual, expected) {
+    return {
-      return {
+      compare: function(actual, expected) {
-        pass: util.equals(actual, expected, customEqualityTesters)
+        var result = {
-      };
+          pass: false
+        };
+
+        result.pass = util.equals(actual, expected, customEqualityTesters);
+
+        return result;
+      }
     };
   }
 

src/core/matchers/toHaveBeenCalled.js

@@ -1,24 +1,26 @@
 getJasmineRequireObj().toHaveBeenCalled = function(j$) {
 
   function toHaveBeenCalled() {
-    return function(actual) {
+    return {
-      var result = {};
+      compare: function(actual) {
+        var result = {};
 
-      if (!j$.isSpy(actual)) {
+        if (!j$.isSpy(actual)) {
-        throw new Error('Expected a spy, but got ' + j$.pp(actual) + '.');
+          throw new Error('Expected a spy, but got ' + j$.pp(actual) + '.');
+        }
+
+        if (arguments.length > 1) {
+          throw new Error('toHaveBeenCalled does not take arguments, use toHaveBeenCalledWith');
+        }
+
+        result.pass = actual.calls.any();
+
+        result.message = result.pass ?
+          "Expected spy " + actual.and.identity() + " not to have been called." :
+          "Expected spy " + actual.and.identity() + " to have been called.";
+
+        return result;
       }
-
-      if (arguments.length > 1) {
-        throw new Error('toHaveBeenCalled does not take arguments, use toHaveBeenCalledWith');
-      }
-
-      result.pass = actual.calls.any();
-
-      result.message = result.pass ?
-        "Expected spy " + actual.and.identity() + " not to have been called." :
-        "Expected spy " + actual.and.identity() + " to have been called.";
-
-      return result;
     };
   }
 

src/core/matchers/toHaveBeenCalledWith.js

@@ -1,29 +1,31 @@
 getJasmineRequireObj().toHaveBeenCalledWith = function(j$) {
 
   function toHaveBeenCalledWith(util) {
-    return function() {
+    return {
-      var args = Array.prototype.slice.call(arguments, 0),
+      compare: function() {
-      actual = args[0],
+        var args = Array.prototype.slice.call(arguments, 0),
-      expectedArgs = args.slice(1),
+          actual = args[0],
-      result = { pass: false };
+          expectedArgs = args.slice(1),
+          result = { pass: false };
 
-      if (!j$.isSpy(actual)) {
+        if (!j$.isSpy(actual)) {
-        throw new Error('Expected a spy, but got ' + j$.pp(actual) + '.');
+          throw new Error('Expected a spy, but got ' + j$.pp(actual) + '.');
-      }
+        }
+
+        if (!actual.calls.any()) {
+          result.message = "Expected spy " + actual.and.identity() + " to have been called with " + j$.pp(expectedArgs) + " but it was never called.";
+          return result;
+        }
+
+        if (util.contains(actual.calls.allArgs(), expectedArgs)) {
+          result.pass = true;
+          result.message = "Expected spy " + actual.and.identity() + " not to have been called with " + j$.pp(expectedArgs) + " but it was.";
+        } else {
+          result.message = "Expected spy " + actual.and.identity() + " to have been called with " + j$.pp(expectedArgs) + " but actual calls were " + j$.pp(actual.calls.allArgs()).replace(/^\[ | \]$/g, '') + ".";
+        }
 
-      if (!actual.calls.any()) {
-        result.message = "Expected spy " + actual.and.identity() + " to have been called with " + j$.pp(expectedArgs) + " but it was never called.";
         return result;
       }
-
-      if (util.contains(actual.calls.allArgs(), expectedArgs)) {
-        result.pass = true;
-        result.message = "Expected spy " + actual.and.identity() + " not to have been called with " + j$.pp(expectedArgs) + " but it was.";
-      } else {
-        result.message = "Expected spy " + actual.and.identity() + " to have been called with " + j$.pp(expectedArgs) + " but actual calls were " + j$.pp(actual.calls.allArgs()).replace(/^\[ | \]$/g, '') + ".";
-      }
-
-      return result;
     };
   }
 

src/core/matchers/toMatch.js

@@ -1,12 +1,14 @@
 getJasmineRequireObj().toMatch = function() {
 
   function toMatch() {
-    return function(actual, expected) {
+    return {
-      var regexp = new RegExp(expected);
+      compare: function(actual, expected) {
+        var regexp = new RegExp(expected);
 
-      return {
+        return {
-        pass: regexp.test(actual)
+          pass: regexp.test(actual)
-      };
+        };
+      }
     };
   }
 

src/core/matchers/toThrow.js

@@ -1,42 +1,44 @@
 getJasmineRequireObj().toThrow = function(j$) {
 
   function toThrow(util) {
-    return function(actual, expected) {
+    return {
-      var result = { pass: false },
+      compare: function(actual, expected) {
-      threw = false,
+        var result = { pass: false },
-      thrown;
+          threw = false,
+          thrown;
 
-      if (typeof actual != "function") {
+        if (typeof actual != "function") {
-        throw new Error("Actual is not a Function");
+          throw new Error("Actual is not a Function");
-      }
+        }
 
-      try {
+        try {
-        actual();
+          actual();
-      } catch (e) {
+        } catch (e) {
-        threw = true;
+          threw = true;
-        thrown = e;
+          thrown = e;
-      }
+        }
 
-      if (!threw) {
+        if (!threw) {
-        result.message = "Expected function to throw an exception.";
+          result.message = "Expected function to throw an exception.";
-        return result;
+          return result;
-      }
+        }
 
-      if (arguments.length == 1) {
+        if (arguments.length == 1) {
-        result.pass = true;
+          result.pass = true;
-        result.message = "Expected function not to throw, but it threw " + j$.pp(thrown) + ".";
+          result.message = "Expected function not to throw, but it threw " + j$.pp(thrown) + ".";
+
+          return result;
+        }
+
+        if (util.equals(thrown, expected)) {
+          result.pass = true;
+          result.message = "Expected function not to throw " + j$.pp(expected) + ".";
+        } else {
+          result.message = "Expected function to throw " + j$.pp(expected) + ", but it threw " +  j$.pp(thrown) + ".";
+        }
 
         return result;
       }
-
-      if (util.equals(thrown, expected)) {
-        result.pass = true;
-        result.message = "Expected function not to throw " + j$.pp(expected) + ".";
-      } else {
-        result.message = "Expected function to throw " + j$.pp(expected) + ", but it threw " +  j$.pp(thrown) + ".";
-      }
-
-      return result;
     };
   }
 

src/core/matchers/toThrowError.js

@@ -1,150 +1,152 @@
 getJasmineRequireObj().toThrowError = function(j$) {
   function toThrowError (util) {
-    return function(actual) {
+    return {
-      var threw = false,
+      compare: function(actual) {
-      thrown,
+        var threw = false,
-      errorType,
+          thrown,
-      message,
+          errorType,
-      regexp,
+          message,
-      name,
+          regexp,
-      constructorName;
+          name,
+          constructorName;
 
-      if (typeof actual != "function") {
+        if (typeof actual != "function") {
-        throw new Error("Actual is not a Function");
+          throw new Error("Actual is not a Function");
-      }
-
-      extractExpectedParams.apply(null, arguments);
-
-      try {
-        actual();
-      } catch (e) {
-        threw = true;
-        thrown = e;
-      }
-
-      if (!threw) {
-        return fail("Expected function to throw an Error.");
-      }
-
-      if (!(thrown instanceof Error)) {
-        return fail("Expected function to throw an Error, but it threw " + thrown + ".");
-      }
-
-      if (arguments.length == 1) {
-        return pass("Expected function not to throw an Error, but it threw " + fnNameFor(thrown) + ".");
-      }
-
-      if (errorType) {
-        name = fnNameFor(errorType);
-        constructorName = fnNameFor(thrown.constructor);
-      }
-
-      if (errorType && message) {
-        if (thrown.constructor == errorType && util.equals(thrown.message, message)) {
-          return pass("Expected function not to throw " + name + " with message \"" + message + "\".");
-        } else {
-          return fail("Expected function to throw " + name + " with message \"" + message +
-                      "\", but it threw " + constructorName + " with message \"" + thrown.message + "\".");
         }
-      }
 
-      if (errorType && regexp) {
+        extractExpectedParams.apply(null, arguments);
-        if (thrown.constructor == errorType && regexp.test(thrown.message)) {
+
-          return pass("Expected function not to throw " + name + " with message matching " + regexp + ".");
+        try {
-        } else {
+          actual();
-          return fail("Expected function to throw " + name + " with message matching " + regexp +
+        } catch (e) {
-                      ", but it threw " + constructorName + " with message \"" + thrown.message + "\".");
+          threw = true;
+          thrown = e;
         }
-      }
 
-      if (errorType) {
+        if (!threw) {
-        if (thrown.constructor == errorType) {
+          return fail("Expected function to throw an Error.");
-          return pass("Expected function not to throw " + name + ".");
-        } else {
-          return fail("Expected function to throw " + name + ", but it threw " + constructorName + ".");
         }
-      }
 
-      if (message) {
+        if (!(thrown instanceof Error)) {
-        if (thrown.message == message) {
+          return fail("Expected function to throw an Error, but it threw " + thrown + ".");
-          return pass("Expected function not to throw an exception with message " + j$.pp(message) + ".");
-        } else {
-          return fail("Expected function to throw an exception with message " + j$.pp(message) +
-                      ", but it threw an exception with message " + j$.pp(thrown.message) + ".");
         }
-      }
 
-      if (regexp) {
-        if (regexp.test(thrown.message)) {
-          return pass("Expected function not to throw an exception with a message matching " + j$.pp(regexp) + ".");
-        } else {
-          return fail("Expected function to throw an exception with a message matching " + j$.pp(regexp) +
-                      ", but it threw an exception with message " + j$.pp(thrown.message) + ".");
-        }
-      }
-
-      function fnNameFor(func) {
-        return func.name || func.toString().match(/^\s*function\s*(\w*)\s*\(/)[1];
-      }
-
-      function pass(notMessage) {
-        return {
-          pass: true,
-          message: notMessage
-        };
-      }
-
-      function fail(message) {
-        return {
-          pass: false,
-          message: message
-        };
-      }
-
-      function extractExpectedParams() {
         if (arguments.length == 1) {
-          return;
+          return pass("Expected function not to throw an Error, but it threw " + fnNameFor(thrown) + ".");
         }
 
-        if (arguments.length == 2) {
+        if (errorType) {
-          var expected = arguments[1];
+          name = fnNameFor(errorType);
+          constructorName = fnNameFor(thrown.constructor);
+        }
 
-          if (expected instanceof RegExp) {
+        if (errorType && message) {
-            regexp = expected;
+          if (thrown.constructor == errorType && util.equals(thrown.message, message)) {
-          } else if (typeof expected == "string") {
+            return pass("Expected function not to throw " + name + " with message \"" + message + "\".");
-            message = expected;
-          } else if (checkForAnErrorType(expected)) {
-            errorType = expected;
-          }
-
-          if (!(errorType || message || regexp)) {
-            throw new Error("Expected is not an Error, string, or RegExp.");
-          }
-        } else {
-          if (checkForAnErrorType(arguments[1])) {
-            errorType = arguments[1];
           } else {
-            throw new Error("Expected error type is not an Error.");
+            return fail("Expected function to throw " + name + " with message \"" + message +
+                        "\", but it threw " + constructorName + " with message \"" + thrown.message + "\".");
           }
+        }
 
-          if (arguments[2] instanceof RegExp) {
+        if (errorType && regexp) {
-            regexp = arguments[2];
+          if (thrown.constructor == errorType && regexp.test(thrown.message)) {
-          } else if (typeof arguments[2] == "string") {
+            return pass("Expected function not to throw " + name + " with message matching " + regexp + ".");
-            message = arguments[2];
           } else {
-            throw new Error("Expected error message is not a string or RegExp.");
+            return fail("Expected function to throw " + name + " with message matching " + regexp +
+                        ", but it threw " + constructorName + " with message \"" + thrown.message + "\".");
           }
         }
-      }
 
-      function checkForAnErrorType(type) {
+        if (errorType) {
-        if (typeof type !== "function") {
+          if (thrown.constructor == errorType) {
-          return false;
+            return pass("Expected function not to throw " + name + ".");
+          } else {
+            return fail("Expected function to throw " + name + ", but it threw " + constructorName + ".");
+          }
         }
 
-        var Surrogate = function() {};
+        if (message) {
-        Surrogate.prototype = type.prototype;
+          if (thrown.message == message) {
-        return (new Surrogate()) instanceof Error;
+            return pass("Expected function not to throw an exception with message " + j$.pp(message) + ".");
+          } else {
+            return fail("Expected function to throw an exception with message " + j$.pp(message) +
+                        ", but it threw an exception with message " + j$.pp(thrown.message) + ".");
+          }
+        }
+
+        if (regexp) {
+          if (regexp.test(thrown.message)) {
+            return pass("Expected function not to throw an exception with a message matching " + j$.pp(regexp) + ".");
+          } else {
+            return fail("Expected function to throw an exception with a message matching " + j$.pp(regexp) +
+                        ", but it threw an exception with message " + j$.pp(thrown.message) + ".");
+          }
+        }
+
+        function fnNameFor(func) {
+            return func.name || func.toString().match(/^\s*function\s*(\w*)\s*\(/)[1];
+        }
+
+        function pass(notMessage) {
+          return {
+            pass: true,
+            message: notMessage
+          };
+        }
+
+        function fail(message) {
+          return {
+            pass: false,
+            message: message
+          };
+        }
+
+        function extractExpectedParams() {
+          if (arguments.length == 1) {
+            return;
+          }
+
+          if (arguments.length == 2) {
+            var expected = arguments[1];
+
+            if (expected instanceof RegExp) {
+              regexp = expected;
+            } else if (typeof expected == "string") {
+              message = expected;
+            } else if (checkForAnErrorType(expected)) {
+              errorType = expected;
+            }
+
+            if (!(errorType || message || regexp)) {
+              throw new Error("Expected is not an Error, string, or RegExp.");
+            }
+          } else {
+            if (checkForAnErrorType(arguments[1])) {
+              errorType = arguments[1];
+            } else {
+              throw new Error("Expected error type is not an Error.");
+            }
+
+            if (arguments[2] instanceof RegExp) {
+              regexp = arguments[2];
+            } else if (typeof arguments[2] == "string") {
+              message = arguments[2];
+            } else {
+              throw new Error("Expected error message is not a string or RegExp.");
+            }
+          }
+        }
+
+        function checkForAnErrorType(type) {
+          if (typeof type !== "function") {
+            return false;
+          }
+
+          var Surrogate = function() {};
+          Surrogate.prototype = type.prototype;
+          return (new Surrogate()) instanceof Error;
+        }
       }
     };
   }