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,10 +10,12 @@ describe("Custom Matchers (Integration)", function() {
     env.it('spec defining a custom matcher', function() {
       env.addMatchers({
         matcherForSpec: function() {
-          return function(actual, expected) {
+          return {
+            compare: function(actual, expected) {
               return { pass: false, message: "matcherForSpec: actual: " + actual + "; expected: " + expected };
             }
           }
+        }
       });
 
       env.expect("zzz").matcherForSpec("yyy");
@@ -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,10 +59,12 @@ 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 {
+          compare: function() {
             return { pass: false };
           }
         }
+      }
     });
 
     env.it('spec with an expectation', function() {
@@ -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 {
+            compare: function() {
               return {
                 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 {
+            compare: function() {
               return {
                 pass: true,
                 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 {
+      compare: function(actual, expected) {
         return {
           pass: actual === expected
         };
+      }
     };
   }
 

src/core/matchers/toBeCloseTo.js

@@ -1,7 +1,8 @@
 getJasmineRequireObj().toBeCloseTo = function() {
 
   function toBeCloseTo() {
-    return function(actual, expected, precision) {
+    return {
+      compare: function(actual, expected, precision) {
         if (precision !== 0) {
           precision = precision || 2;
         }
@@ -9,6 +10,7 @@ getJasmineRequireObj().toBeCloseTo = function() {
         return {
           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 {
+      compare: function(actual) {
         return {
           pass: (void 0 !== actual)
         };
+      }
     };
   }
 

src/core/matchers/toBeFalsy.js

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

src/core/matchers/toBeGreaterThan.js

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

src/core/matchers/toBeLessThan.js

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

src/core/matchers/toBeNaN.js

@@ -1,7 +1,8 @@
 getJasmineRequireObj().toBeNaN = function(j$) {
 
   function toBeNaN() {
-    return function(actual) {
+    return {
+      compare: function(actual) {
         var result = {
           pass: (actual !== actual)
         };
@@ -13,6 +14,7 @@ getJasmineRequireObj().toBeNaN = function(j$) {
         }
 
         return result;
+      }
     };
   }
 

src/core/matchers/toBeNull.js

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

src/core/matchers/toBeTruthy.js

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

src/core/matchers/toBeUndefined.js

@@ -1,10 +1,12 @@
 getJasmineRequireObj().toBeUndefined = function() {
 
   function toBeUndefined() {
-    return function(actual) {
+    return {
+      compare: function(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 {
+      compare: function(actual, expected) {
+
         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 {
-        pass: util.equals(actual, expected, customEqualityTesters)
+      compare: function(actual, expected) {
+        var result = {
+          pass: false
         };
+
+        result.pass = util.equals(actual, expected, customEqualityTesters);
+
+        return result;
+      }
     };
   }
 

src/core/matchers/toHaveBeenCalled.js

@@ -1,7 +1,8 @@
 getJasmineRequireObj().toHaveBeenCalled = function(j$) {
 
   function toHaveBeenCalled() {
-    return function(actual) {
+    return {
+      compare: function(actual) {
         var result = {};
 
         if (!j$.isSpy(actual)) {
@@ -19,6 +20,7 @@ getJasmineRequireObj().toHaveBeenCalled = function(j$) {
           "Expected spy " + actual.and.identity() + " to have been called.";
 
         return result;
+      }
     };
   }
 

src/core/matchers/toHaveBeenCalledWith.js

@@ -1,7 +1,8 @@
 getJasmineRequireObj().toHaveBeenCalledWith = function(j$) {
 
   function toHaveBeenCalledWith(util) {
-    return function() {
+    return {
+      compare: function() {
         var args = Array.prototype.slice.call(arguments, 0),
           actual = args[0],
           expectedArgs = args.slice(1),
@@ -24,6 +25,7 @@ getJasmineRequireObj().toHaveBeenCalledWith = function(j$) {
         }
 
         return result;
+      }
     };
   }
 

src/core/matchers/toMatch.js

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

src/core/matchers/toThrow.js

@@ -1,7 +1,8 @@
 getJasmineRequireObj().toThrow = function(j$) {
 
   function toThrow(util) {
-    return function(actual, expected) {
+    return {
+      compare: function(actual, expected) {
         var result = { pass: false },
           threw = false,
           thrown;
@@ -37,6 +38,7 @@ getJasmineRequireObj().toThrow = function(j$) {
         }
 
         return result;
+      }
     };
   }
 

src/core/matchers/toThrowError.js

@@ -1,6 +1,7 @@
 getJasmineRequireObj().toThrowError = function(j$) {
   function toThrowError (util) {
-    return function(actual) {
+    return {
+      compare: function(actual) {
         var threw = false,
           thrown,
           errorType,
@@ -146,6 +147,7 @@ getJasmineRequireObj().toThrowError = function(j$) {
           Surrogate.prototype = type.prototype;
           return (new Surrogate()) instanceof Error;
         }
+      }
     };
   }