oojspec 0.2.0 → 0.3.0

data/vendor/assets/javascripts/buster/samsam.js

@@ -0,0 +1,399 @@
+((typeof define === "function" && define.amd && function (m) { define("samsam", m); }) ||
+ (typeof module === "object" &&
+      function (m) { module.exports = m(); }) || // Node
+ function (m) { this.samsam = m(); } // Browser globals
+)(function () {
+    var o = Object.prototype;
+    var div = typeof document !== "undefined" && document.createElement("div");
+
+    function isNaN(value) {
+        // Unlike global isNaN, this avoids type coercion
+        // typeof check avoids IE host object issues, hat tip to
+        // lodash
+        var val = value; // JsLint thinks value !== value is "weird"
+        return typeof value === "number" && value !== val;
+    }
+
+    function getClass(value) {
+        // Returns the internal [[Class]] by calling Object.prototype.toString
+        // with the provided value as this. Return value is a string, naming the
+        // internal class, e.g. "Array"
+        return o.toString.call(value).split(/[ \]]/)[1];
+    }
+
+    /**
+     * @name samsam.isArguments
+     * @param Object object
+     *
+     * Returns ``true`` if ``object`` is an ``arguments`` object,
+     * ``false`` otherwise.
+     */
+    function isArguments(object) {
+        if (getClass(object) === 'Arguments') { return true; }
+        if (typeof object !== "object" || typeof object.length !== "number" ||
+                getClass(object) === "Array") {
+            return false;
+        }
+        if (typeof object.callee == "function") { return true; }
+        try {
+            object[object.length] = 6;
+            delete object[object.length];
+        } catch (e) {
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * @name samsam.isElement
+     * @param Object object
+     *
+     * Returns ``true`` if ``object`` is a DOM element node. Unlike
+     * Underscore.js/lodash, this function will return ``false`` if ``object``
+     * is an *element-like* object, i.e. a regular object with a ``nodeType``
+     * property that holds the value ``1``.
+     */
+    function isElement(object) {
+        if (!object || object.nodeType !== 1 || !div) { return false; }
+        try {
+            object.appendChild(div);
+            object.removeChild(div);
+        } catch (e) {
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * @name samsam.keys
+     * @param Object object
+     *
+     * Return an array of own property names.
+     */
+    function keys(object) {
+        var ks = [], prop;
+        for (prop in object) {
+            if (o.hasOwnProperty.call(object, prop)) { ks.push(prop); }
+        }
+        return ks;
+    }
+
+    /**
+     * @name samsam.isDate
+     * @param Object value
+     *
+     * Returns true if the object is a ``Date``, or *date-like*. Duck typing
+     * of date objects work by checking that the object has a ``getTime``
+     * function whose return value equals the return value from the object's
+     * ``valueOf``.
+     */
+    function isDate(value) {
+        return typeof value.getTime == "function" &&
+            value.getTime() == value.valueOf();
+    }
+
+    /**
+     * @name samsam.isNegZero
+     * @param Object value
+     *
+     * Returns ``true`` if ``value`` is ``-0``.
+     */
+    function isNegZero(value) {
+        return value === 0 && 1 / value === -Infinity;
+    }
+
+    /**
+     * @name samsam.equal
+     * @param Object obj1
+     * @param Object obj2
+     *
+     * Returns ``true`` if two objects are strictly equal. Compared to
+     * ``===`` there are two exceptions:
+     *
+     *   - NaN is considered equal to NaN
+     *   - -0 and +0 are not considered equal
+     */
+    function identical(obj1, obj2) {
+        if (obj1 === obj2 || (isNaN(obj1) && isNaN(obj2))) {
+            return obj1 !== 0 || isNegZero(obj1) === isNegZero(obj2);
+        }
+    }
+
+
+    /**
+     * @name samsam.deepEqual
+     * @param Object obj1
+     * @param Object obj2
+     *
+     * Deep equal comparison. Two values are "deep equal" if:
+     *
+     *   - They are equal, according to samsam.identical
+     *   - They are both date objects representing the same time
+     *   - They are both arrays containing elements that are all deepEqual
+     *   - They are objects with the same set of properties, and each property
+     *     in ``obj1`` is deepEqual to the corresponding property in ``obj2``
+     *
+     * Supports cyclic objects.
+     */
+    function deepEqualCyclic(obj1, obj2) {
+
+        // used for cyclic comparison
+        // contain already visited objects
+        var objects1 = [],
+            objects2 = [],
+        // contain pathes (position in the object structure)
+        // of the already visited objects
+        // indexes same as in objects arrays
+            paths1 = [],
+            paths2 = [],
+        // contains combinations of already compared objects
+        // in the manner: { "$1['ref']$2['ref']": true }
+            compared = {};
+
+        /**
+         * used to check, if the value of a property is an object
+         * (cyclic logic is only needed for objects)
+         * only needed for cyclic logic
+         */
+        function isObject(value) {
+
+            if (typeof value === 'object' && value !== null &&
+                    !(value instanceof Boolean) &&
+                    !(value instanceof Date)    &&
+                    !(value instanceof Number)  &&
+                    !(value instanceof RegExp)  &&
+                    !(value instanceof String)) {
+
+                return true;
+            }
+
+            return false;
+        }
+
+        /**
+         * returns the index of the given object in the
+         * given objects array, -1 if not contained
+         * only needed for cyclic logic
+         */
+        function getIndex(objects, obj) {
+
+            var i;
+            for (i = 0; i < objects.length; i++) {
+                if (objects[i] === obj) {
+                    return i;
+                }
+            }
+
+            return -1;
+        }
+
+        // does the recursion for the deep equal check
+        return (function deepEqual(obj1, obj2, path1, path2) {
+            var type1 = typeof obj1;
+            var type2 = typeof obj2;
+
+            // == null also matches undefined
+            if (obj1 === obj2 ||
+                    isNaN(obj1) || isNaN(obj2) ||
+                    obj1 == null || obj2 == null ||
+                    type1 !== "object" || type2 !== "object") {
+
+                return identical(obj1, obj2);
+            }
+
+            // Elements are only equal if identical(expected, actual)
+            if (isElement(obj1) || isElement(obj2)) { return false; }
+
+            var isDate1 = isDate(obj1), isDate2 = isDate(obj2);
+            if (isDate1 || isDate2) {
+                if (!isDate1 || !isDate2 || obj1.getTime() !== obj2.getTime()) {
+                    return false;
+                }
+            }
+
+            if (obj1 instanceof RegExp && obj2 instanceof RegExp) {
+                if (obj1.toString() !== obj2.toString()) { return false; }
+            }
+
+            var class1 = getClass(obj1);
+            var class2 = getClass(obj2);
+            var keys1 = keys(obj1);
+            var keys2 = keys(obj2);
+
+            if (isArguments(obj1) || isArguments(obj2)) {
+                if (obj1.length !== obj2.length) { return false; }
+            } else {
+                if (type1 !== type2 || class1 !== class2 ||
+                        keys1.length !== keys2.length) {
+                    return false;
+                }
+            }
+
+            var key, i, l,
+                // following vars are used for the cyclic logic
+                value1, value2,
+                isObject1, isObject2,
+                index1, index2,
+                newPath1, newPath2;
+
+            for (i = 0, l = keys1.length; i < l; i++) {
+                key = keys1[i];
+                if (!o.hasOwnProperty.call(obj2, key)) {
+                    return false;
+                }
+
+                // Start of the cyclic logic
+
+                value1 = obj1[key];
+                value2 = obj2[key];
+
+                isObject1 = isObject(value1);
+                isObject2 = isObject(value2);
+
+                // determine, if the objects were already visited
+                // (it's faster to check for isObject first, than to
+                // get -1 from getIndex for non objects)
+                index1 = isObject1 ? getIndex(objects1, value1) : -1;
+                index2 = isObject2 ? getIndex(objects2, value2) : -1;
+
+                // determine the new pathes of the objects
+                // - for non cyclic objects the current path will be extended
+                //   by current property name
+                // - for cyclic objects the stored path is taken
+                newPath1 = index1 !== -1
+                    ? paths1[index1]
+                    : path1 + '[' + JSON.stringify(key) + ']';
+                newPath2 = index2 !== -1
+                    ? paths2[index2]
+                    : path2 + '[' + JSON.stringify(key) + ']';
+
+                // stop recursion if current objects are already compared
+                if (compared[newPath1 + newPath2]) {
+                    return true;
+                }
+
+                // remember the current objects and their pathes
+                if (index1 === -1 && isObject1) {
+                    objects1.push(value1);
+                    paths1.push(newPath1);
+                }
+                if (index2 === -1 && isObject2) {
+                    objects2.push(value2);
+                    paths2.push(newPath2);
+                }
+
+                // remember that the current objects are already compared
+                if (isObject1 && isObject2) {
+                    compared[newPath1 + newPath2] = true;
+                }
+
+                // End of cyclic logic
+
+                // neither value1 nor value2 is a cycle
+                // continue with next level
+                if (!deepEqual(value1, value2, newPath1, newPath2)) {
+                    return false;
+                }
+            }
+
+            return true;
+
+        }(obj1, obj2, '$1', '$2'));
+    }
+
+    var match;
+
+    function arrayContains(array, subset) {
+        if (subset.length === 0) { return true; }
+        var i, l, j, k;
+        for (i = 0, l = array.length; i < l; ++i) {
+            if (match(array[i], subset[0])) {
+                for (j = 0, k = subset.length; j < k; ++j) {
+                    if (!match(array[i + j], subset[j])) { return false; }
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * @name samsam.match
+     * @param Object object
+     * @param Object matcher
+     *
+     * Compare arbitrary value ``object`` with matcher.
+     */
+    match = function match(object, matcher) {
+        if (matcher && typeof matcher.test === "function") {
+            return matcher.test(object);
+        }
+
+        if (typeof matcher === "function") {
+            return matcher(object) === true;
+        }
+
+        if (typeof matcher === "string") {
+            matcher = matcher.toLowerCase();
+            var notNull = typeof object === "string" || !!object;
+            return notNull &&
+                (String(object)).toLowerCase().indexOf(matcher) >= 0;
+        }
+
+        if (typeof matcher === "number") {
+            return matcher === object;
+        }
+
+        if (typeof matcher === "boolean") {
+            return matcher === object;
+        }
+
+        if (typeof(matcher) === "undefined") {
+            return typeof(object) === "undefined";
+        }
+
+        if (matcher === null) {
+            return object === null;
+        }
+
+        if (getClass(object) === "Array" && getClass(matcher) === "Array") {
+            return arrayContains(object, matcher);
+        }
+
+        if (matcher && typeof matcher === "object") {
+            if (matcher === object) {
+                return true;
+            }
+            var prop;
+            for (prop in matcher) {
+                var value = object[prop];
+                if (typeof value === "undefined" &&
+                        typeof object.getAttribute === "function") {
+                    value = object.getAttribute(prop);
+                }
+                if (matcher[prop] === null || typeof matcher[prop] === 'undefined') {
+                    if (value !== matcher[prop]) {
+                        return false;
+                    }
+                } else if (typeof  value === "undefined" || !match(value, matcher[prop])) {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        throw new Error("Matcher was not a string, a number, a " +
+                        "function, a boolean or an object");
+    };
+
+    return {
+        isArguments: isArguments,
+        isElement: isElement,
+        isDate: isDate,
+        isNegZero: isNegZero,
+        identical: identical,
+        deepEqual: deepEqualCyclic,
+        match: match,
+        keys: keys
+    };
+});

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: oojspec
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Rodrigo Rosenfeld Rosas
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-17 00:00:00.000000000 Z
+date: 2015-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: coffee-rails
@@ -65,12 +65,15 @@ files:
 - lib/tasks/oojspec_tasks.rake
 - vendor/assets/images/buster/logo.png
 - vendor/assets/javascripts/buster/all.js.coffee
-- vendor/assets/javascripts/buster/buster-assertions.js
+- vendor/assets/javascripts/buster/bane.js
 - vendor/assets/javascripts/buster/buster-core.js
 - vendor/assets/javascripts/buster/buster-event-emitter.js
-- vendor/assets/javascripts/buster/buster-format.js
 - vendor/assets/javascripts/buster/expect.js
+- vendor/assets/javascripts/buster/formatio.js
 - vendor/assets/javascripts/buster/html.js
+- vendor/assets/javascripts/buster/lodash.js
+- vendor/assets/javascripts/buster/referee.js
+- vendor/assets/javascripts/buster/samsam.js
 - vendor/assets/javascripts/buster/stack-filter.js
 - vendor/assets/stylesheets/buster/buster-test.css
 homepage: http://github.com/rosenfeld/oojspec
@@ -92,7 +95,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Object-oriented client-side testing

data/vendor/assets/javascripts/buster/buster-assertions.js

@@ -1,782 +0,0 @@
-/*jslint eqeqeq: false, onevar: false, plusplus: false*/
-/*global buster, require, module*/
-(function () {
-    var isCommonJS = typeof require == "function" && typeof module == "object";
-    if (isCommonJS) buster = require("buster-core");
-    var toString = Object.prototype.toString;
-    var slice = Array.prototype.slice;
-    var assert, refute, ba = buster.assertions = buster.eventEmitter.create();
-
-    if (isCommonJS) {
-        module.exports = buster.assertions;
-    }
-
-    function countAssertion() {
-        if (typeof ba.count != "number") {
-            ba.count = 0;
-        }
-
-        ba.count += 1;
-    }
-
-    ba.count = countAssertion;
-
-    function assertEnoughArguments(name, args, num) {
-        if (args.length < num) {
-            ba.fail("[" + name + "] Expected to receive at least " +
-                        num + " argument" + (num > 1 ? "s" : ""));
-            return false;
-        }
-
-        return true;
-    }
-
-    function defineAssertion(type, name, func, fl, messageValues) {
-        ba[type][name] = function () {
-            var fullName = type + "." + name;
-            countAssertion();
-            if (!assertEnoughArguments(fullName, arguments, fl || func.length)) return;
-
-            var failed = false;
-
-            var ctx = {
-                fail: function () {
-                    failed = true;
-                    var failArgs = [type, name].concat(slice.call(arguments));
-                    fail.apply(this, failArgs);
-                    return true;
-                }
-            };
-
-            var args = slice.call(arguments, 0);
-
-            if (typeof messageValues == "function") {
-                args = messageValues.apply(this, args);
-            }
-
-            if (!func.apply(ctx, arguments)) {
-                return fail.apply(ctx, [type, name, "message"].concat(args));
-            }
-
-            if (!failed) {
-                ba.emit.apply(ba, ["pass", fullName].concat(args));
-            }
-        };
-    }
-
-    ba.add = function (name, options) {
-        var refuteArgs;
-
-        if (options.refute) {
-            refuteArgs = options.refute.length;
-        } else {
-            refuteArgs = options.assert.length;
-            options.refute = function () {
-                return !options.assert.apply(this, arguments);
-            };
-        }
-
-        var values = options && options.values; // TODO: Remove
-        defineAssertion("assert", name, options.assert, options.assert.length, values);
-        defineAssertion("refute", name, options.refute, refuteArgs, values);
-
-        assert[name].message = options.assertMessage;
-        refute[name].message = options.refuteMessage;
-
-        if (options.expectation) {
-            if (ba.expect && ba.expect.wrapAssertion) {
-                ba.expect.wrapAssertion(name, options.expectation);
-            } else {
-                assert[name].expectationName = options.expectation;
-                refute[name].expectationName = options.expectation;
-            }
-        }
-    };
-
-    function interpolate(string, property, value) {
-        return string.replace(new RegExp("\\$\\{" + property + "\\}", "g"), value);
-    }
-
-    function interpolatePosArg(message, values) {
-        var value;
-        values = values || [];
-
-        for (var i = 0, l = values.length; i < l; i++) {
-            message = interpolate(message, i, ba.format(values[i]));
-        }
-
-        return message;
-    }
-
-    function interpolateProperties(msg, properties) {
-        for (var prop in properties) {
-            msg = interpolate(msg, prop, ba.format(properties[prop]));
-        }
-
-        return msg || "";
-    }
-
-    function fail(type, assertion, msg) {
-        delete this.fail;
-        var message = interpolateProperties(
-            interpolatePosArg(ba[type][assertion][msg] || msg,
-                              [].slice.call(arguments, 3)), this);
-        ba.fail("[" + type + "." + assertion + "] " + message);
-    }
-
-    function isDate(value) {
-        // Duck typed dates, allows objects to take on the role of dates
-        // without actually being dates
-        return typeof value.getTime == "function" &&
-            value.getTime() == value.valueOf();
-    }
-
-    ba.isDate = isDate;
-
-    // Fixes NaN === NaN (should be true) and
-    // -0 === +0 (should be false)
-    // http://wiki.ecmascript.org/doku.php?id=harmony:egal
-    function egal(x, y) {
-        if (x === y) {
-            // 0 === -0, but they are not identical
-            return x !== 0 || 1 / x === 1 / y;
-        }
-        
-        // NaN !== NaN, but they are identical.
-        // NaNs are the only non-reflexive value, i.e., if x !== x,
-        // then x is a NaN.
-        // isNaN is broken: it converts its argument to number, so
-        // isNaN("foo") => true
-        return x !== x && y !== y;
-    }
-
-    function areEqual(expected, actual) {
-        if (egal(expected, actual)) {
-            return true;
-        }
-
-        // Elements are only equal if expected === actual
-        if (buster.isElement(expected) || buster.isElement(actual)) {
-            return false;
-        }
-
-        // null and undefined only pass for null === null and
-        // undefined === undefined
-        /*jsl: ignore*/
-        if (expected == null || actual == null) {
-            return actual === expected;
-        }
-        /*jsl: end*/
-
-        if (isDate(expected) || isDate(actual)) {
-            return isDate(expected) && isDate(actual) &&
-                expected.getTime() == actual.getTime();
-        }
-
-        var useCoercingEquality = typeof expected != "object" || typeof actual != "object";
-
-        if (expected instanceof RegExp && actual instanceof RegExp) {
-            if (expected.toString() != actual.toString()) {
-                return false;
-            }
-
-            useCoercingEquality = false;
-        }
-
-        // Arrays can only be equal to arrays
-        var expectedStr = toString.call(expected);
-        var actualStr = toString.call(actual);
-
-        // Coerce and compare when primitives are involved
-        if (useCoercingEquality) {
-            return expectedStr != "[object Array]" && actualStr != "[object Array]" &&
-                expected == actual;
-        }
-
-        var expectedKeys = ba.keys(expected);
-        var actualKeys = ba.keys(actual);
-
-        if (isArguments(expected) || isArguments(actual)) {
-            if (expected.length != actual.length) {
-                return false;
-            }
-        } else {
-            if (typeof expected != typeof actual || expectedStr != actualStr ||
-                expectedKeys.length != actualKeys.length) {
-                return false;
-            }
-        }
-
-        var key;
-
-        for (var i = 0, l = expectedKeys.length; i < l; i++) {
-            key = expectedKeys[i];
-
-            if (!Object.prototype.hasOwnProperty.call(actual, key) ||
-                !areEqual(expected[key], actual[key])) {
-                return false;
-            }
-        }
-
-        return true;
-    }
-
-    ba.deepEqual = areEqual;
-
-    assert = ba.assert = function assert(actual, message) {
-        countAssertion();
-        if (!assertEnoughArguments("assert", arguments, 1)) return;
-
-        if (!actual) {
-            var val = ba.format(actual);
-            ba.fail(message || "[assert] Expected " + val + " to be truthy");
-        } else {
-            ba.emit("pass", "assert", message || "", actual);
-        }
-    };
-
-    assert.toString = function () {
-        return "buster.assert";
-    };
-
-    refute = ba.refute = function (actual, message) {
-        countAssertion();
-        if (!assertEnoughArguments("refute", arguments, 1)) return;
-
-        if (actual) {
-            var val = ba.format(actual);
-            ba.fail(message || "[refute] Expected " + val + " to be falsy");
-        } else {
-            ba.emit("pass", "refute", message || "", actual);
-        }
-    };
-
-    assert.message = "[assert] Expected ${0} to be truthy";
-    ba.count = 0;
-
-    ba.fail = function (message) {
-        var exception = new Error(message);
-        exception.name = "AssertionError";
-
-        try {
-            throw exception;
-        } catch (e) {
-            ba.emit("failure", e);
-        }
-
-        if (typeof ba.throwOnFailure != "boolean" || ba.throwOnFailure) {
-            throw exception;
-        }
-    };
-
-    ba.format = function (object) {
-        return "" + object;
-    };
-
-    function msg(message) {
-        if (!message) { return ""; }
-        return message + (/[.:!?]$/.test(message) ? " " : ": ");
-    }
-
-    function actualAndExpectedMessageValues(actual, expected, message) {
-        return [actual, expected, msg(message)]
-    }
-
-    function actualMessageValues(actual) {
-        return [actual, msg(arguments[1])];
-    }
-
-    function actualAndTypeOfMessageValues(actual) {
-        return [actual, typeof actual, msg(arguments[1])];
-    }
-
-    ba.add("same", {
-        assert: function (actual, expected) {
-            return egal(actual, expected);
-        },
-        refute: function (actual, expected) {
-            return !egal(actual, expected);
-        },
-        assertMessage: "${2}${0} expected to be the same object as ${1}",
-        refuteMessage: "${2}${0} expected not to be the same object as ${1}",
-        expectation: "toBe",
-        values: actualAndExpectedMessageValues
-    });
-
-    function multiLineStringDiff(actual, expected, message) {
-        if (actual == expected) return true;
-
-        var message = interpolatePosArg(assert.equals.multiLineStringHeading, [message]),
-            actualLines = actual.split("\n"),
-            expectedLines = expected.split("\n"),
-            lineCount = Math.max(expectedLines.length, actualLines.length),
-            lines = [];
-
-        for (var i = 0; i < lineCount; ++i) {
-            if (expectedLines[i] != actualLines[i]) {
-                lines.push("line " + (i + 1) + ": " + (expectedLines[i] || "") +
-                           "\nwas:    " + (actualLines[i] || ""));
-            }
-        }
-
-        ba.fail("[assert.equals] " + message + lines.join("\n\n"));
-        return false;
-    }
-
-    ba.add("equals", {
-        assert: function (actual, expected) {
-            if (typeof actual == "string" && typeof expected == "string" &&
-                (actual.indexOf("\n") >= 0 || expected.indexOf("\n") >= 0)) {
-                var message = msg(arguments[2]);
-                return multiLineStringDiff.call(this, actual, expected, message);
-            }
-
-            return areEqual(actual, expected);
-        },
-
-        refute: function (actual, expected) {
-            return !areEqual(actual, expected);
-        },
-
-        assertMessage: "${2}${0} expected to be equal to ${1}",
-        refuteMessage: "${2}${0} expected not to be equal to ${1}",
-        expectation: "toEqual",
-        values: actualAndExpectedMessageValues
-    });
-
-    assert.equals.multiLineStringHeading = "${0}Expected multi-line strings to be equal:\n";
-
-    ba.add("greater", {
-        assert: function (actual, expected) {
-            return actual > expected;
-        },
-
-        assertMessage: "${2}Expected ${0} to be greater than ${1}",
-        refuteMessage: "${2}Expected ${0} to be less than or equal to ${1}",
-        expectation: "toBeGreaterThan",
-        values: actualAndExpectedMessageValues
-    });
-
-    ba.add("less", {
-        assert: function (actual, expected) {
-            return actual < expected;
-        },
-
-        assertMessage: "${2}Expected ${0} to be less than ${1}",
-        refuteMessage: "${2}Expected ${0} to be greater than or equal to ${1}",
-        expectation: "toBeLessThan",
-        values: actualAndExpectedMessageValues
-    });
-
-    ba.add("defined", {
-        assert: function (actual) {
-            return typeof actual != "undefined";
-        },
-        assertMessage: "${2}Expected to be defined",
-        refuteMessage: "${2}Expected ${0} (${1}) not to be defined",
-        expectation: "toBeDefined",
-        values: actualAndTypeOfMessageValues
-    });
-
-    ba.add("isNull", {
-        assert: function (actual) {
-            return actual === null;
-        },
-        assertMessage: "${1}Expected ${0} to be null",
-        refuteMessage: "${1}Expected not to be null",
-        expectation: "toBeNull",
-        values: actualMessageValues
-    });
-
-    function match(object, matcher) {
-        if (matcher && typeof matcher.test == "function") {
-            return matcher.test(object);
-        }
-
-        if (typeof matcher == "function") {
-            return matcher(object) === true;
-        }
-
-        if (typeof matcher == "string") {
-            matcher = matcher.toLowerCase();
-            return !!object && ("" + object).toLowerCase().indexOf(matcher) >= 0;
-        }
-
-        if (typeof matcher == "number") {
-            return matcher == object;
-        }
-
-        if (typeof matcher == "boolean") {
-            return matcher === object;
-        }
-
-        if (matcher && typeof matcher == "object") {
-            for (var prop in matcher) {
-                if (!match(object[prop], matcher[prop])) {
-                    return false;
-                }
-            }
-
-            return true;
-        }
-
-        throw new Error("Matcher (" + ba.format(matcher) + ") was not a " +
-                        "string, a number, a function, a boolean or an object");
-    }
-
-    ba.match = match;
-
-    ba.add("match", {
-        assert: function (actual, matcher) {
-            var passed;
-
-            try {
-                passed = match(actual, matcher);
-            } catch (e) {
-                return this.fail("exceptionMessage", e.message, msg(arguments[2]));
-            }
-
-            return passed;
-        },
-
-        refute: function (actual, matcher) {
-            var passed;
-
-            try {
-                passed = match(actual, matcher);
-            } catch (e) {
-                return this.fail("exceptionMessage", e.message);
-            }
-
-            return !passed;
-        },
-
-        assertMessage: "${2}${0} expected to match ${1}",
-        refuteMessage: "${2}${0} expected not to match ${1}",
-        expectation: "toMatch",
-        values: actualAndExpectedMessageValues
-    });
-
-    assert.match.exceptionMessage = "${1}${0}";
-    refute.match.exceptionMessage = "${1}${0}";
-
-    ba.add("isObject", {
-        assert: function (actual) {
-            return typeof actual == "object" && !!actual;
-        },
-        assertMessage: "${2}${0} (${1}) expected to be object and not null",
-        refuteMessage: "${2}${0} expected to be null or not an object",
-        expectation: "toBeObject",
-        values: actualAndTypeOfMessageValues
-    });
-
-    ba.add("isFunction", {
-        assert: function (actual) {
-            return typeof actual == "function";
-        },
-        assertMessage: "${2}${0} (${1}) expected to be function",
-        refuteMessage: "${2}${0} expected not to be function",
-        expectation: "toBeFunction",
-        values: function (actual) {
-            return [("" + actual).replace("\n", ""), typeof actual, msg(arguments[1])];
-        }
-    });
-
-    ba.add("isTrue", {
-        assert: function (actual) {
-            return actual === true;
-        },
-        assertMessage: "${1}Expected ${0} to be true",
-        refuteMessage: "${1}Expected ${0} to not be true",
-        expectation: "toBeTrue",
-        values: actualMessageValues
-    });
-
-    ba.add("isFalse", {
-        assert: function (actual) {
-            return actual === false;
-        },
-        assertMessage: "${1}Expected ${0} to be false",
-        refuteMessage: "${1}Expected ${0} to not be false",
-        expectation: "toBeFalse",
-        values: actualMessageValues
-    });
-
-    ba.add("isString", {
-        assert: function (actual) {
-            return typeof actual == "string";
-        },
-        assertMessage: "${2}Expected ${0} (${1}) to be string",
-        refuteMessage: "${2}Expected ${0} not to be string",
-        expectation: "toBeString",
-        values: actualAndTypeOfMessageValues
-    });
-
-    ba.add("isBoolean", {
-        assert: function (actual) {
-            return typeof actual == "boolean";
-        },
-        assertMessage: "${2}Expected ${0} (${1}) to be boolean",
-        refuteMessage: "${2}Expected ${0} not to be boolean",
-        expectation: "toBeBoolean",
-        values: actualAndTypeOfMessageValues
-    });
-
-    ba.add("isNumber", {
-        assert: function (actual) {
-            return typeof actual == "number" && !isNaN(actual);
-        },
-        assertMessage: "${2}Expected ${0} (${1}) to be a non-NaN number",
-        refuteMessage: "${2}Expected ${0} to be NaN or another non-number value",
-        expectation: "toBeNumber",
-        values: actualAndTypeOfMessageValues
-    });
-
-    ba.add("isNaN", {
-        assert: function (actual) {
-            return typeof actual == "number" && isNaN(actual);
-        },
-        assertMessage: "${2}Expected ${0} to be NaN",
-        refuteMessage: "${2}Expected not to be NaN",
-        expectation: "toBeNaN",
-        values: actualAndTypeOfMessageValues
-    });
-
-    ba.add("isArray", {
-        assert: function (actual) {
-            return toString.call(actual) == "[object Array]";
-        },
-        assertMessage: "${2}Expected ${0} to be array",
-        refuteMessage: "${2}Expected ${0} not to be array",
-        expectation: "toBeArray",
-        values: actualAndTypeOfMessageValues
-    });
-
-    function isArrayLike(object) {
-        return toString.call(object) == "[object Array]" ||
-            (!!object && typeof object.length == "number" &&
-            typeof object.splice == "function") ||
-            ba.isArguments(object);
-    }
-
-    ba.isArrayLike = isArrayLike;
-
-    ba.add("isArrayLike", {
-        assert: function (actual) {
-            return isArrayLike(actual);
-        },
-        assertMessage: "${2}Expected ${0} to be array like",
-        refuteMessage: "${2}Expected ${0} not to be array like",
-        expectation: "toBeArrayLike",
-        values: actualAndTypeOfMessageValues
-    });
-
-    function captureException(callback) {
-        try {
-            callback();
-        } catch (e) {
-            return e;
-        }
-
-        return null;
-    }
-
-    ba.captureException = captureException;
-
-    assert.exception = function (callback, exception, message) {
-        countAssertion();
-        if (!assertEnoughArguments("assert.exception", arguments, 1)) return
-
-        if (!callback) {
-            return;
-        }
-
-        var err = captureException(callback);
-        message = msg(message);
-
-        if (!err) {
-            if (exception) {
-                return fail.call({}, "assert", "exception", "typeNoExceptionMessage",
-                                 message, exception);
-            } else {
-                return fail.call({}, "assert", "exception", "message",
-                                 message, exception);
-            }
-        }
-
-        if (exception && err.name != exception) {
-            if (typeof window != "undefined" && typeof console != "undefined") {
-                console.log(err);
-            }
-
-            return fail.call({}, "assert", "exception", "typeFailMessage",
-                             message, exception, err.name, err.message);
-        }
-
-        ba.emit("pass", "assert.exception", message, callback, exception);
-    };
-
-    assert.exception.typeNoExceptionMessage = "${0}Expected ${1} but no exception was thrown";
-    assert.exception.message = "${0}Expected exception";
-    assert.exception.typeFailMessage = "${0}Expected ${1} but threw ${2} (${3})";
-    assert.exception.expectationName = "toThrow";
-
-    refute.exception = function (callback) {
-        countAssertion();
-        if (!assertEnoughArguments("refute.exception", arguments, 1)) return;
-
-        var err = captureException(callback);
-
-        if (err) {
-            fail.call({}, "refute", "exception", "message",
-                      msg(arguments[1]), err.name, err.message, callback);
-        } else {
-            ba.emit("pass", "refute.exception", callback);
-        }
-    };
-
-    refute.exception.message = "${0}Expected not to throw but threw ${1} (${2})";
-    refute.exception.expectationName = "toThrow";
-
-    ba.add("near", {
-        assert: function (actual, expected, delta) {
-            return Math.abs(actual - expected) <= delta;
-        },
-        assertMessage: "${3}Expected ${0} to be equal to ${1} +/- ${2}",
-        refuteMessage: "${3}Expected ${0} not to be equal to ${1} +/- ${2}",
-        expectation: "toBeNear",
-        values: function (actual, expected, delta, message) {
-            return [actual, expected, delta, msg(message)];
-        }
-    });
-
-    ba.add("hasPrototype", {
-        assert: function (actual, protoObj) {
-            return protoObj.isPrototypeOf(actual);
-        },
-        assertMessage: "${2}Expected ${0} to have ${1} on its prototype chain",
-        refuteMessage: "${2}Expected ${0} not to have ${1} on its prototype chain",
-        expectation: "toHavePrototype",
-        values: actualAndExpectedMessageValues
-    });
-
-    ba.add("contains", {
-        assert: function (haystack, needle) {
-            for (var i = 0; i < haystack.length; i++) {
-                if (haystack[i] === needle) {
-                    return true;
-                }
-            }
-            return false;
-        },
-        assertMessage: "${2}Expected [${0}] to contain ${1}",
-        refuteMessage: "${2}Expected [${0}] not to contain ${1}",
-        expectation: "toContain",
-        values: actualAndExpectedMessageValues
-    });
-
-    ba.add("tagName", {
-        assert: function (element, tagName) {
-            if (!element.tagName) {
-                return this.fail("noTagNameMessage", tagName, element, msg(arguments[2]));
-            }
-
-            return tagName.toLowerCase &&
-                tagName.toLowerCase() == element.tagName.toLowerCase();
-        },
-        assertMessage: "${2}Expected tagName to be ${0} but was ${1}",
-        refuteMessage: "${2}Expected tagName not to be ${0}",
-        expectation: "toHaveTagName",
-        values: function (element, tagName, message) {
-            return [tagName, element.tagName, msg(message)];
-        }
-    });
-
-    assert.tagName.noTagNameMessage = "${2}Expected ${1} to have tagName property";
-    refute.tagName.noTagNameMessage = "${2}Expected ${1} to have tagName property";
-
-    function indexOf(arr, item) {
-        for (var i = 0, l = arr.length; i < l; i++) {
-            if (arr[i] == item) {
-                return i;
-            }
-        }
-
-        return -1;
-    }
-
-    ba.add("className", {
-        assert: function (element, className) {
-            if (typeof element.className == "undefined") {
-                return this.fail("noClassNameMessage", className, element, msg(arguments[2]));
-            }
-
-            var expected = typeof className == "string" ? className.split(" ") : className;
-            var actual = element.className.split(" ");
-
-            for (var i = 0, l = expected.length; i < l; i++) {
-                if (indexOf(actual, expected[i]) < 0) {
-                    return false;
-                }
-            }
-
-            return true;
-        },
-        assertMessage: "${2}Expected object's className to include ${0} but was ${1}",
-        refuteMessage: "${2}Expected object's className not to include ${0}",
-        expectation: "toHaveClassName",
-        values: function (element, className, message) {
-            return [className, element.className, msg(message)];
-        }
-    });
-
-    assert.className.noClassNameMessage = "${2}Expected object to have className property";
-    refute.className.noClassNameMessage = "${2}Expected object to have className property";
-
-    if (typeof module != "undefined") {
-        ba.expect = function () {
-            ba.expect = require("./buster-assertions/expect");
-            return ba.expect.apply(exports, arguments);
-        };
-    }
-
-    function isArguments(obj) {
-        if (typeof obj != "object" || typeof obj.length != "number" ||
-            toString.call(obj) == "[object Array]") {
-            return false;
-        }
-
-        if (typeof obj.callee == "function") {
-            return true;
-        }
-
-        try {
-            obj[obj.length] = 6;
-            delete obj[obj.length];
-        } catch (e) {
-            return true;
-        }
-
-        return false;
-    }
-
-    ba.isArguments = isArguments;
-
-    if (Object.keys) {
-        ba.keys = function (obj) {
-            return Object.keys(obj)
-        };
-    } else {
-        ba.keys = function (object) {
-            var keys = [];
-
-            for (var prop in object) {
-                if (Object.prototype.hasOwnProperty.call(object, prop)) {
-                    keys.push(prop);
-                }
-            }
-
-            return keys;
-        }
-    }
-}());