Modularized the solution a bit more.

MIT.License

@@ -0,0 +1,20 @@
+Copyright (c) 2008-2011 Pivotal Labs
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

lib/expectThat.js

@@ -52,6 +52,19 @@ expectThat = (function(expectThat) {
     }
   };
 })(expectThat || (expectThat = {}));
+(function(expectThat) {
+  expectThat.util = {
+    extend: function(destintation, source) {
+      var method, name;
+      for (name in source) {
+        method = source[name];
+        destintation[name] = method;
+      }
+      return destintation;
+    }
+  };
+  return this;
+})(expectThat || (expectThat = {}));
 (function(expectThat) {
   expectThat.api = {
     be: function(expected) {
@@ -69,6 +82,19 @@ expectThat = (function(expectThat) {
         "expected": expected
       };
     },
+    extendApi: function(fn, assertProvder) {
+      var description;
+      if (!Object.prototype.should) {
+        this.init(assertProvder);
+      }
+      description = fn.toString().match(/^[^\{]*\{((.*\s*)*)\}/m)[1];
+      return description.replace(/(\^\s+|\s)+$/g, "").replace(/[(\^(?)]/g, " ").replace(/.should/g, " should").replace(/return/g, " ").replace(/shouldnt/g, "shouldn't").replace(/void 0/g, "null").replace(/!= null/g, "").replace(/typeof null !== "undefined" && null !== null/g, "undefined");
+    }
+  };
+  return this;
+})(expectThat || (expectThat = {}));
+(function(expectThat) {
+  expectThat.api.customMatchers = {
     greaterThan: function(expected) {
       return {
         "assertionType": "greaterThan",
@@ -86,16 +112,9 @@ expectThat = (function(expectThat) {
           return actual < expected;
         }
       };
-    },
-    extendApi: function(fn, assertProvder) {
-      var description;
-      if (!Object.prototype.should) {
-        this.init(assertProvder);
-      }
-      description = fn.toString().match(/^[^\{]*\{((.*\s*)*)\}/m)[1];
-      return description.replace(/(\^\s+|\s)+$/g, "").replace(/[(\^(?)]/g, " ").replace(/.should/g, " should").replace(/return/g, " ").replace(/shouldnt/g, "shouldn't").replace(/void 0/g, "null").replace(/!= null/g, "").replace(/typeof null !== "undefined" && null !== null/g, "undefined");
     }
   };
+  expectThat.util.extend(expectThat.api, expectThat.customMatchers);
   return this;
 })(expectThat || (expectThat = {}));
 (function(expectThat, pavlov) {
@@ -107,6 +126,7 @@ expectThat = (function(expectThat) {
     }
   };
   pavlov.util.extend(expectThat, expectThat.api);
+  pavlov.util.extend(expectThat, expectThat.api.customMatchers);
   pavlov.util.extend(expectThat, expectThat.api.pavlov);
   return pavlov.util.extend(pavlov.api, expectThat);
 })(expectThat || (expectThat = {}), window.pavlov);

src/api.coffee

@@ -4,8 +4,6 @@
         to: (expected) -> expected
         equal: (expected) -> expected
         throwException: (expected) -> "assertionType": "throw", "expected": expected
-        greaterThan: (expected) -> "assertionType": "greaterThan", "expected": expected, "expr": (actual, expected) -> actual > expected
-        lessThan: (expected) -> "assertionType": "lessThan", "expected": expected, "expr": (actual, expected) -> actual < expected
         extendApi: (fn, assertProvder) ->
             @.init assertProvder if not Object.prototype.should
             description = fn.toString().match(/^[^\{]*\{((.*\s*)*)\}/m)[1]

src/api.customMatchers.coffee

@@ -0,0 +1,8 @@
+((expectThat) ->
+    expectThat.api.customMatchers =
+        greaterThan: (expected) -> "assertionType": "greaterThan", "expected": expected, "expr": (actual, expected) -> actual > expected
+        lessThan: (expected) -> "assertionType": "lessThan", "expected": expected, "expr": (actual, expected) -> actual < expected
+
+    expectThat.util.extend expectThat.api, expectThat.customMatchers
+    @
+) expectThat or= {}

src/api.pavlov.coffee

@@ -7,6 +7,7 @@
             pavlov.api.it testDescription, fn
 
     pavlov.util.extend expectThat, expectThat.api
+    pavlov.util.extend expectThat, expectThat.api.customMatchers
     pavlov.util.extend expectThat, expectThat.api.pavlov
     pavlov.util.extend pavlov.api, expectThat
 ) expectThat or= {}, window.pavlov 

src/core.coffee

@@ -0,0 +1,35 @@
+expectThat = ((expectThat) ->
+    init: (assertProvider) ->
+        _this = @
+        Object.prototype.should = (expected) ->
+            _this.evaluateAssertion assertProvider, true, @, expected
+        Object.prototype.shouldnt = (expected) ->
+            _this.evaluateAssertion assertProvider, false, @, expected
+        @
+    evaluateAssertion: (assertProvider, isShould, actual, expectedValueProvider) ->
+        expected = expectedValueProvider
+        customAssertion = expectedValueProvider
+        if typeof expectedValueProvider is "function" then customAssertion = expectedValueProvider()
+        if typeof customAssertion isnt "undefined" and customAssertion isnt null
+            assertionType = customAssertion.assertionType
+            expected = customAssertion.expected if typeof customAssertion.expected isnt "undefined"
+
+        # TODO: This is a mess. Replace with an array that can be extended?
+        if typeof assertionType isnt "undefined"
+            if assertionType is "throw"
+                if typeof customAssertion.expected isnt "undefined"
+                    assertProvider.assert(actual).throwsException expected
+                else
+                    assertProvider.assert(actual).throwsException()
+            else
+                # TODO: Add a nice error message if expectedVal is null/undefined or not a function
+                assertionToEvaluate = assertProvider.assert(customAssertion.expr actual, expected)
+                if isShould
+                    if assertionToEvaluate isnt null then assertionToEvaluate.isTrue()
+                else
+                    if assertionToEvaluate isnt null then assertionToEvaluate.isFalse()
+        else if isShould
+            assertProvider.assert(actual).isEqualTo expected
+        else if not isShould
+            assertProvider.assert(actual).isNotEqualTo expected
+) expectThat or= {}

src/expectThat.coffee

@@ -1,39 +1,5 @@
-expectThat = ((expectThat) ->
-    #executeAssertion: (
-    init: (assertProvider) ->
-        _this = @
-        Object.prototype.should = (expected) ->
-            _this.evaluateAssertion assertProvider, true, @, expected
-        Object.prototype.shouldnt = (expected) ->
-            _this.evaluateAssertion assertProvider, false, @, expected
-        @
-    evaluateAssertion: (assertProvider, isShould, actual, expectedValueProvider) ->
-        expected = expectedValueProvider
-        customAssertion = expectedValueProvider
-        if typeof expectedValueProvider is "function" then customAssertion = expectedValueProvider()
-        if typeof customAssertion isnt "undefined" and customAssertion isnt null
-            assertionType = customAssertion.assertionType
-            expected = customAssertion.expected if typeof customAssertion.expected isnt "undefined"
-
-        # TODO: This is a mess. Replace with an array that can be extended?
-        if typeof assertionType isnt "undefined"
-            if assertionType is "throw"
-                if typeof customAssertion.expected isnt "undefined"
-                    assertProvider.assert(actual).throwsException expected
-                else
-                    assertProvider.assert(actual).throwsException()
-            else
-                # TODO: Add a nice error message if expectedVal is null/undefined or not a function
-                assertionToEvaluate = assertProvider.assert(customAssertion.expr actual, expected)
-                if isShould
-                    if assertionToEvaluate isnt null then assertionToEvaluate.isTrue()
-                else
-                    if assertionToEvaluate isnt null then assertionToEvaluate.isFalse()
-        else if isShould
-            assertProvider.assert(actual).isEqualTo expected
-        else if not isShould
-            assertProvider.assert(actual).isNotEqualTo expected
-) expectThat or= {}
-
+###import "core.coffee" ###
+###import "util.coffee" ###
 ###import "api.coffee" ###
+###import "api.customMatchers.coffee" ###
 ###import "api.pavlov.coffee" ###

src/util.coffee

@@ -0,0 +1,7 @@
+((expectThat) ->
+    expectThat.util =
+        extend: (destintation, source) ->
+            destintation[name] = method for name, method of source
+            destintation
+    @
+) expectThat or= {}