oojspec 0.0.1

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

@@ -0,0 +1,222 @@
+var buster = (function (setTimeout, B) {
+    var isNode = typeof require == "function" && typeof module == "object";
+    var div = typeof document != "undefined" && document.createElement("div");
+    var F = function () {};
+
+    var buster = {
+        bind: function bind(obj, methOrProp) {
+            var method = typeof methOrProp == "string" ? obj[methOrProp] : methOrProp;
+            var args = Array.prototype.slice.call(arguments, 2);
+            return function () {
+                var allArgs = args.concat(Array.prototype.slice.call(arguments));
+                return method.apply(obj, allArgs);
+            };
+        },
+
+        partial: function partial(fn) {
+            var args = [].slice.call(arguments, 1);
+            return function () {
+                return fn.apply(this, args.concat([].slice.call(arguments)));
+            };
+        },
+
+        create: function create(object) {
+            F.prototype = object;
+            return new F();
+        },
+
+        extend: function extend(target) {
+            if (!target) { return; }
+            for (var i = 1, l = arguments.length, prop; i < l; ++i) {
+                for (prop in arguments[i]) {
+                    target[prop] = arguments[i][prop];
+                }
+            }
+            return target;
+        },
+
+        nextTick: function nextTick(callback) {
+            if (typeof process != "undefined" && process.nextTick) {
+                return process.nextTick(callback);
+            }
+            setTimeout(callback, 0);
+        },
+
+        functionName: function functionName(func) {
+            if (!func) return "";
+            if (func.displayName) return func.displayName;
+            if (func.name) return func.name;
+            var matches = func.toString().match(/function\s+([^\(]+)/m);
+            return matches && matches[1] || "";
+        },
+
+        isNode: function isNode(obj) {
+            if (!div) return false;
+            try {
+                obj.appendChild(div);
+                obj.removeChild(div);
+            } catch (e) {
+                return false;
+            }
+            return true;
+        },
+
+        isElement: function isElement(obj) {
+            return obj && obj.nodeType === 1 && buster.isNode(obj);
+        },
+
+        isArray: function isArray(arr) {
+            return Object.prototype.toString.call(arr) == "[object Array]";
+        },
+
+        flatten: function flatten(arr) {
+            var result = [], arr = arr || [];
+            for (var i = 0, l = arr.length; i < l; ++i) {
+                result = result.concat(buster.isArray(arr[i]) ? flatten(arr[i]) : arr[i]);
+            }
+            return result;
+        },
+
+        each: function each(arr, callback) {
+            for (var i = 0, l = arr.length; i < l; ++i) {
+                callback(arr[i]);
+            }
+        },
+
+        map: function map(arr, callback) {
+            var results = [];
+            for (var i = 0, l = arr.length; i < l; ++i) {
+                results.push(callback(arr[i]));
+            }
+            return results;
+        },
+
+        parallel: function parallel(fns, callback) {
+            function cb(err, res) {
+                if (typeof callback == "function") {
+                    callback(err, res);
+                    callback = null;
+                }
+            }
+            if (fns.length == 0) { return cb(null, []); }
+            var remaining = fns.length, results = [];
+            function makeDone(num) {
+                return function done(err, result) {
+                    if (err) { return cb(err); }
+                    results[num] = result;
+                    if (--remaining == 0) { cb(null, results); }
+                };
+            }
+            for (var i = 0, l = fns.length; i < l; ++i) {
+                fns[i](makeDone(i));
+            }
+        },
+
+        series: function series(fns, callback) {
+            function cb(err, res) {
+                if (typeof callback == "function") {
+                    callback(err, res);
+                }
+            }
+            var remaining = fns.slice();
+            var results = [];
+            function callNext() {
+                if (remaining.length == 0) return cb(null, results);
+                var promise = remaining.shift()(next);
+                if (promise && typeof promise.then == "function") {
+                    promise.then(buster.partial(next, null), next);
+                }
+            }
+            function next(err, result) {
+                if (err) return cb(err);
+                results.push(result);
+                callNext();
+            }
+            callNext();
+        },
+
+        countdown: function countdown(num, done) {
+            return function () {
+                if (--num == 0) done();
+            };
+        }
+    };
+
+    if (typeof process === "object") {
+        var crypto = require("crypto");
+        var path = require("path");
+
+        buster.tmpFile = function (fileName) {
+            var hashed = crypto.createHash("sha1");
+            hashed.update(fileName);
+            var tmpfileName = hashed.digest("hex");
+
+            if (process.platform == "win32") {
+                return path.join(process.env["TEMP"], tmpfileName);
+            } else {
+                return path.join("/tmp", tmpfileName);
+            }
+        };
+    }
+
+    if (Array.prototype.some) {
+        buster.some = function (arr, fn, thisp) {
+            return arr.some(fn, thisp);
+        };
+    } else {
+        // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/some
+        buster.some = function (arr, fun, thisp) {
+            "use strict";
+            if (arr == null) { throw new TypeError(); }
+            arr = Object(arr);
+            var len = arr.length >>> 0;
+            if (typeof fun !== "function") { throw new TypeError(); }
+
+            for (var i = 0; i < len; i++) {
+                if (arr.hasOwnProperty(i) && fun.call(thisp, arr[i], i, arr)) {
+                    return true;
+                }
+            }
+
+            return false;
+        };
+    }
+
+    if (Array.prototype.filter) {
+        buster.filter = function (arr, fn, thisp) {
+            return arr.filter(fn, thisp);
+        };
+    } else {
+        // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/filter
+        buster.filter = function (fn, thisp) {
+            "use strict";
+            if (this == null) { throw new TypeError(); }
+
+            var t = Object(this);
+            var len = t.length >>> 0;
+            if (typeof fn != "function") { throw new TypeError(); }
+
+            var res = [];
+            for (var i = 0; i < len; i++) {
+                if (i in t) {
+                    var val = t[i]; // in case fun mutates this
+                    if (fn.call(thisp, val, i, t)) { res.push(val); }
+                }
+            }
+
+            return res;
+        };
+    }
+
+    if (isNode) {
+        module.exports = buster;
+        buster.eventEmitter = require("./buster-event-emitter");
+        Object.defineProperty(buster, "defineVersionGetter", {
+            get: function () {
+                return require("./define-version-getter");
+            }
+        });
+    }
+
+    return buster.extend(B || {}, buster);
+}(setTimeout, buster));

data/vendor/assets/javascripts/buster/buster-event-emitter.js

@@ -0,0 +1,152 @@
+/*jslint eqeqeq: false, onevar: false, plusplus: false*/
+/*global buster, require, module*/
+if (typeof require == "function" && typeof module == "object") {
+    var buster = require("./buster-core");
+}
+
+(function () {
+    function eventListeners(eventEmitter, event) {
+        if (!eventEmitter.listeners) {
+            eventEmitter.listeners = {};
+        }
+
+        if (!eventEmitter.listeners[event]) {
+            eventEmitter.listeners[event] = [];
+        }
+
+        return eventEmitter.listeners[event];
+    }
+
+    function throwLater(event, error) {
+        buster.nextTick(function () {
+            error.message = event + " listener threw error: " + error.message;
+            throw error;
+        });
+    }
+
+    function addSupervisor(emitter, listener, thisObject) {
+        if (!emitter.supervisors) { emitter.supervisors = []; }
+        emitter.supervisors.push({
+            listener: listener,
+            thisObject: thisObject
+        });
+    }
+
+    function notifyListener(emitter, event, listener, args) {
+        try {
+            listener.listener.apply(listener.thisObject || emitter, args);
+        } catch (e) {
+            throwLater(event, e);
+        }
+    }
+
+    buster.eventEmitter = {
+        create: function () {
+            return buster.create(this);
+        },
+
+        addListener: function addListener(event, listener, thisObject) {
+            if (typeof event === "function") {
+                return addSupervisor(this, event, listener);
+            }
+            if (typeof listener != "function") {
+                throw new TypeError("Listener is not function");
+            }
+            eventListeners(this, event).push({
+                listener: listener,
+                thisObject: thisObject
+            });
+        },
+
+        once: function once(event, listener, thisObject) {
+            var self = this;
+            this.addListener(event, listener);
+
+            var wrapped = function () {
+                self.removeListener(event, listener);
+                self.removeListener(event, wrapped);
+            };
+            this.addListener(event, wrapped);
+        },
+
+        hasListener: function hasListener(event, listener, thisObject) {
+            var listeners = eventListeners(this, event);
+
+            for (var i = 0, l = listeners.length; i < l; i++) {
+                if (listeners[i].listener === listener &&
+                    listeners[i].thisObject === thisObject) {
+                    return true;
+                }
+            }
+
+            return false;
+        },
+
+        removeListener: function (event, listener) {
+            var listeners = eventListeners(this, event);
+
+            for (var i = 0, l = listeners.length; i < l; ++i) {
+                if (listeners[i].listener == listener) {
+                    listeners.splice(i, 1);
+                    return;
+                }
+            }
+        },
+
+        emit: function emit(event) {
+            var listeners = eventListeners(this, event).slice();
+            var args = Array.prototype.slice.call(arguments, 1);
+
+            for (var i = 0, l = listeners.length; i < l; i++) {
+                notifyListener(this, event, listeners[i], args);
+            }
+
+            listeners = this.supervisors || [];
+            args = Array.prototype.slice.call(arguments);
+            for (i = 0, l = listeners.length; i < l; ++i) {
+                notifyListener(this, event, listeners[i], args);
+            }
+        },
+
+        bind: function (object, events) {
+            var method;
+
+            if (!events) {
+                for (method in object) {
+                    if (object.hasOwnProperty(method) && typeof object[method] == "function") {
+                        this.addListener(method, object[method], object);
+                    }
+                }
+            } else if (typeof events == "string" ||
+                       Object.prototype.toString.call(events) == "[object Array]") {
+                events = typeof events == "string" ? [events] : events;
+
+                for (var i = 0, l = events.length; i < l; ++i) {
+                    this.addListener(events[i], object[events[i]], object);
+                }
+            } else {
+                for (var prop in events) {
+                    if (events.hasOwnProperty(prop)) {
+                        method = events[prop];
+
+                        if (typeof method == "function") {
+                            object[buster.functionName(method) || prop] = method;
+                        } else {
+                            method = object[events[prop]];
+                        }
+
+                        this.addListener(prop, method, object);
+                    }
+                }
+            }
+
+            return object;
+        }
+    };
+
+    buster.eventEmitter.on = buster.eventEmitter.addListener;
+}());
+
+if (typeof module != "undefined") {
+    module.exports = buster.eventEmitter;
+}

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

@@ -0,0 +1,199 @@
+if (typeof buster === "undefined") {
+    var buster = {};
+}
+
+if (typeof module === "object" && typeof require === "function") {
+    buster = require("buster-core");
+}
+
+buster.format = buster.format || {};
+buster.format.excludeConstructors = ["Object", /^.$/];
+buster.format.quoteStrings = true;
+
+buster.format.ascii = (function () {
+    "use strict";
+
+    var hasOwn = Object.prototype.hasOwnProperty;
+
+    var specialObjects = [];
+    if (typeof global != "undefined") {
+        specialObjects.push({ obj: global, value: "[object global]" });
+    }
+    if (typeof document != "undefined") {
+        specialObjects.push({ obj: document, value: "[object HTMLDocument]" });
+    }
+    if (typeof window != "undefined") {
+        specialObjects.push({ obj: window, value: "[object Window]" });
+    }
+
+    function keys(object) {
+        var k = Object.keys && Object.keys(object) || [];
+
+        if (k.length == 0) {
+            for (var prop in object) {
+                if (hasOwn.call(object, prop)) {
+                    k.push(prop);
+                }
+            }
+        }
+
+        return k.sort();
+    }
+
+    function isCircular(object, objects) {
+        if (typeof object != "object") {
+            return false;
+        }
+
+        for (var i = 0, l = objects.length; i < l; ++i) {
+            if (objects[i] === object) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    function ascii(object, processed, indent) {
+        if (typeof object == "string") {
+            var quote = typeof this.quoteStrings != "boolean" || this.quoteStrings;
+            return processed || quote ? '"' + object + '"' : object;
+        }
+
+        if (typeof object == "function" && !(object instanceof RegExp)) {
+            return ascii.func(object);
+        }
+
+        processed = processed || [];
+
+        if (isCircular(object, processed)) {
+            return "[Circular]";
+        }
+
+        if (Object.prototype.toString.call(object) == "[object Array]") {
+            return ascii.array.call(this, object);
+        }
+
+        if (!object) {
+            return "" + object;
+        }
+
+        if (buster.isElement(object)) {
+            return ascii.element(object);
+        }
+
+        if (typeof object.toString == "function" &&
+            object.toString !== Object.prototype.toString) {
+            return object.toString();
+        }
+
+        for (var i = 0, l = specialObjects.length; i < l; i++) {
+            if (object === specialObjects[i].obj) {
+                return specialObjects[i].value;
+            }
+        }
+
+        return ascii.object.call(this, object, processed, indent);
+    }
+
+    ascii.func = function (func) {
+        return "function " + buster.functionName(func) + "() {}";
+    };
+
+    ascii.array = function (array, processed) {
+        processed = processed || [];
+        processed.push(array);
+        var pieces = [];
+
+        for (var i = 0, l = array.length; i < l; ++i) {
+            pieces.push(ascii.call(this, array[i], processed));
+        }
+
+        return "[" + pieces.join(", ") + "]";
+    };
+
+    ascii.object = function (object, processed, indent) {
+        processed = processed || [];
+        processed.push(object);
+        indent = indent || 0;
+        var pieces = [], properties = keys(object), prop, str, obj;
+        var is = "";
+        var length = 3;
+
+        for (var i = 0, l = indent; i < l; ++i) {
+            is += " ";
+        }
+
+        for (i = 0, l = properties.length; i < l; ++i) {
+            prop = properties[i];
+            obj = object[prop];
+
+            if (isCircular(obj, processed)) {
+                str = "[Circular]";
+            } else {
+                str = ascii.call(this, obj, processed, indent + 2);
+            }
+
+            str = (/\s/.test(prop) ? '"' + prop + '"' : prop) + ": " + str;
+            length += str.length;
+            pieces.push(str);
+        }
+
+        var cons = ascii.constructorName.call(this, object);
+        var prefix = cons ? "[" + cons + "] " : ""
+
+        return (length + indent) > 80 ?
+            prefix + "{\n  " + is + pieces.join(",\n  " + is) + "\n" + is + "}" :
+            prefix + "{ " + pieces.join(", ") + " }";
+    };
+
+    ascii.element = function (element) {
+        var tagName = element.tagName.toLowerCase();
+        var attrs = element.attributes, attribute, pairs = [], attrName;
+
+        for (var i = 0, l = attrs.length; i < l; ++i) {
+            attribute = attrs.item(i);
+            attrName = attribute.nodeName.toLowerCase().replace("html:", "");
+
+            if (attrName == "contenteditable" && attribute.nodeValue == "inherit") {
+                continue;
+            }
+
+            if (!!attribute.nodeValue) {
+                pairs.push(attrName + "=\"" + attribute.nodeValue + "\"");
+            }
+        }
+
+        var formatted = "<" + tagName + (pairs.length > 0 ? " " : "");
+        var content = element.innerHTML;
+
+        if (content.length > 20) {
+            content = content.substr(0, 20) + "[...]";
+        }
+
+        var res = formatted + pairs.join(" ") + ">" + content + "</" + tagName + ">";
+
+        return res.replace(/ contentEditable="inherit"/, "");
+    };
+
+    ascii.constructorName = function (object) {
+        var name = buster.functionName(object && object.constructor);
+        var excludes = this.excludeConstructors || buster.format.excludeConstructors || [];
+
+        for (var i = 0, l = excludes.length; i < l; ++i) {
+            if (typeof excludes[i] == "string" && excludes[i] == name) {
+                return "";
+            } else if (excludes[i].test && excludes[i].test(name)) {
+                return "";
+            }
+        }
+
+        return name;
+    };
+
+    return ascii;
+}());
+
+if (typeof module != "undefined") {
+    module.exports = buster.format;
+}

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

@@ -0,0 +1,63 @@
+if (typeof module == "object" && typeof require == "function") {
+    var buster = require("buster-core");
+    buster.assertions = require("../buster-assertions");
+}
+
+(function (ba) {
+    ba.expectation = {};
+
+    ba.expect = function (actual) {
+        var expectation = buster.extend(buster.create(ba.expectation), {
+            actual: actual,
+            assertMode: true
+        });
+        expectation.not = buster.create(expectation);
+        expectation.not.assertMode = false;
+        return expectation;
+    };
+
+    ba.expect.wrapAssertion = function (assertion, expectation) {
+        ba.expectation[expectation] = function () {
+            var args = [this.actual].concat(Array.prototype.slice.call(arguments));
+            var type = this.assertMode ? "assert" : "refute";
+            var callFunc;
+
+            if (assertion === "assert") {
+                callFunc = this.assertMode ? ba.assert : ba.refute;
+            } else if (assertion === "refute") {
+                callFunc = this.assertMode ? ba.refute : ba.assert;
+            } else {
+                callFunc = ba[type][assertion];
+            }
+
+            try {
+                return callFunc.apply(ba.expect, args);
+            } catch (e) {
+                e.message = (e.message || "").replace(
+                    "[" + type + "." + assertion + "]",
+                    "[expect." + (this.assertMode ? "" : "not.") + expectation + "]");
+                throw e;
+            }
+        };
+    };
+
+    var prop, expectationName;
+
+    for (prop in ba.assert) {
+        if (ba.assert[prop].expectationName) {
+            expectationName = ba.assert[prop].expectationName;
+            ba.expect.wrapAssertion(prop, expectationName);
+        }
+    }
+
+    ba.expect.wrapAssertion("assert", "toBeTruthy");
+    ba.expect.wrapAssertion("refute", "toBeFalsy");
+
+    if (ba.expectation.toBeNear) {
+        ba.expectation.toBeCloseTo = ba.expectation.toBeNear;
+    }
+
+    if (typeof module == "object") {
+        module.exports = ba.expect;
+    }
+}(buster.assertions));