oojspec 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 724e22dc3d2dd4d39d3e328440d4280d93ace90b
-  data.tar.gz: 884d9a5c7b832154afc8eb5c99a244ea8b5e17ed
+  metadata.gz: 3becd6c69bdfbacd5d8986b464ca2a3f89967650
+  data.tar.gz: c46d2342a87bacabdabb0b5903124b852d7b9de0
 SHA512:
-  metadata.gz: 7c30d3e29b42ec72bf256ca75562c58d7a988e2c7be902310632ba3cd422b5b8e1ea8ff9be23e6f307840b96a08f27c6d13cc09480349a7762d68a546b2e89ca
-  data.tar.gz: c58b6b70eb7cbe4543046933f5bd0085c94cf22453535a8d0ed1321f62c5a0b933e14fe2208412532194f593498672b204058d73db1daf72dc753c34de4692e3
+  metadata.gz: be7c90618f90c30527b19540ab9c8112048739a59059701b2d81538ac921db278d004e1f19e9d0b4e4b6064b0e078b90b0d1ca911c47349bf68acf91deb6290f
+  data.tar.gz: 488cf3725b34c1fa025d0f34ec626ab70e98f3eff64e5f909fa8d155090b6a322ce3b4935c6caf3a136a842caf4a1c8b268f0c0d9bb23f7e3b4c609ea5e99312

data/lib/assets/javascripts/oojspec/runner.js.coffee

@@ -24,9 +24,9 @@ _.extend oojspec, new class OojspecRunner
     @on 'iframe-end', (w)=> @_iframeByWindow[w.location.pathname].style.display = 'none'
 
   _registerEventHandlers: ->
-    @assertions = buster.assertions
-    (logFormatter = buster.create buster.format).quoteStrings = false
-    @assertions.format = buster.bind logFormatter, "ascii"
+    @assertions = referee
+    logFormatter = formatio.configure quoteStrings: false
+    @assertions.format = -> logFormatter.ascii.apply logFormatter, arguments
     @assertions.on 'pass',    => @stats.assertions++
     @assertions.on 'failure', => @stats.failures++
     #@events.on 'context:start', => @stats.contexts++
@@ -90,13 +90,13 @@ RESERVED_FOR_EXAMPLE_DSL = ['assert', 'expect', 'fail', 'refute', 'waitsFor', 'r
 class Description
   RESERVED = RESERVED_FOR_DESCRIPTION_DSL.concat RESERVED_FOR_EXAMPLE_DSL
 
-  constructor: (@description, @block)->
+  constructor: (@description, @block, @beforeBlocks = [], @afterBlocks = [])->
     if @description.runSpecs or @description.prototype?.runSpecs
       @block = @description
       @description = @block.description or @block.name
 
   processDsl: (@params, @binding, @bare)->
-    @events = params.events
+    @events = @params.events
     @dsl = new DescribeDsl
     (@block.runSpecs or @block.prototype?.runSpecs) and @detectBindingError()
 
@@ -126,7 +126,7 @@ class Description
 
   removeDsl: -> delete @binding[p] for p in RESERVED_FOR_DESCRIPTION_DSL; return
 
-  run: (@params, @onFinish, @beforeBlocks = [], @afterBlocks = [])->
+  run: (@params, @onFinish)->
     @events.emit 'context:start', name: @description
     if @bindingError
       @events.emit 'test:error', name: @description, error: @bindingError
@@ -134,7 +134,7 @@ class Description
     else
       @doRun()
 
-  doRun: -> @runAround @beforeBlocks, @afterBlocks, @onDescriptionFinished, @processDescriptionBlock
+  doRun: -> @runAround [], [], @onDescriptionFinished, @processDescriptionBlock
 
   onDescriptionFinished: (error)=>
     if error and not error.handled
@@ -154,6 +154,7 @@ class Description
     (@onExamplesFinished(); return) unless @dsl._examples_.length
     nextStep = @dsl._examples_.shift()
     (@reportDeferred(nextStep.description); @runNextStep(); return) if nextStep.pending
+    @prependHooks nextStep
     nextTick =
       if nextStep instanceof Description then =>
         nextStep.run @params, @runNextStep, @dsl._beforeBlocks_, @dsl._afterBlocks_
@@ -170,6 +171,12 @@ class Description
     @events.emit 'test:error', { name, error }
     @onFinish(error)
 
+  prependHooks: (nextStep)->
+    @cloneAndPrepend nextStep, type for type in ['beforeBlocks', 'afterBlocks']
+
+  cloneAndPrepend: (nextStep, type)->
+    (nextStep[type] = nextStep[type].slice 0).unshift this[type]...
+
   reportDeferred: (description)-> @events.emit 'test:deferred', name: description
 
 class DescribeDsl

data/lib/oojspec/version.rb

@@ -1,3 +1,3 @@
 module Oojspec
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/vendor/assets/javascripts/buster/all.js.coffee

@@ -1,3 +1,5 @@
+# =require buster/lodash
+# =require buster/samsam
 # =require ./buster-core
 # =require ./buster-event-emitter
 # =require_tree .

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

@@ -0,0 +1,174 @@
+((typeof define === "function" && define.amd && function (m) { define("bane", m); }) ||
+ (typeof module === "object" && function (m) { module.exports = m(); }) ||
+ function (m) { this.bane = m(); }
+)(function () {
+    "use strict";
+    var slice = Array.prototype.slice;
+
+    function handleError(event, error, errbacks) {
+        var i, l = errbacks.length;
+        if (l > 0) {
+            for (i = 0; i < l; ++i) { errbacks[i](event, error); }
+            return;
+        }
+        setTimeout(function () {
+            error.message = event + " listener threw error: " + error.message;
+            throw error;
+        }, 0);
+    }
+
+    function assertFunction(fn) {
+        if (typeof fn !== "function") {
+            throw new TypeError("Listener is not function");
+        }
+        return fn;
+    }
+
+    function supervisors(object) {
+        if (!object.supervisors) { object.supervisors = []; }
+        return object.supervisors;
+    }
+
+    function listeners(object, event) {
+        if (!object.listeners) { object.listeners = {}; }
+        if (event && !object.listeners[event]) { object.listeners[event] = []; }
+        return event ? object.listeners[event] : object.listeners;
+    }
+
+    function errbacks(object) {
+        if (!object.errbacks) { object.errbacks = []; }
+        return object.errbacks;
+    }
+
+    /**
+     * @signature var emitter = bane.createEmitter([object]);
+     *
+     * Create a new event emitter. If an object is passed, it will be modified
+     * by adding the event emitter methods (see below).
+     */
+    function createEventEmitter(object) {
+        object = object || {};
+
+        function notifyListener(event, listener, args) {
+            try {
+                listener.listener.apply(listener.thisp || object, args);
+            } catch (e) {
+                handleError(event, e, errbacks(object));
+            }
+        }
+
+        object.on = function (event, listener, thisp) {
+            if (typeof event === "function") {
+                return supervisors(this).push({
+                    listener: event,
+                    thisp: listener
+                });
+            }
+            listeners(this, event).push({
+                listener: assertFunction(listener),
+                thisp: thisp
+            });
+        };
+
+        object.off = function (event, listener) {
+            var fns, events, i, l;
+            if (!event) {
+                fns = supervisors(this);
+                fns.splice(0, fns.length);
+
+                events = listeners(this);
+                for (i in events) {
+                    if (events.hasOwnProperty(i)) {
+                        fns = listeners(this, i);
+                        fns.splice(0, fns.length);
+                    }
+                }
+
+                fns = errbacks(this);
+                fns.splice(0, fns.length);
+
+                return;
+            }
+            if (typeof event === "function") {
+                fns = supervisors(this);
+                listener = event;
+            } else {
+                fns = listeners(this, event);
+            }
+            if (!listener) {
+                fns.splice(0, fns.length);
+                return;
+            }
+            for (i = 0, l = fns.length; i < l; ++i) {
+                if (fns[i].listener === listener) {
+                    fns.splice(i, 1);
+                    return;
+                }
+            }
+        };
+
+        object.once = function (event, listener, thisp) {
+            var wrapper = function () {
+                object.off(event, wrapper);
+                listener.apply(this, arguments);
+            };
+
+            object.on(event, wrapper, thisp);
+        };
+
+        object.bind = function (object, events) {
+            var prop, i, l;
+            if (!events) {
+                for (prop in object) {
+                    if (typeof object[prop] === "function") {
+                        this.on(prop, object[prop], object);
+                    }
+                }
+            } else {
+                for (i = 0, l = events.length; i < l; ++i) {
+                    if (typeof object[events[i]] === "function") {
+                        this.on(events[i], object[events[i]], object);
+                    } else {
+                        throw new Error("No such method " + events[i]);
+                    }
+                }
+            }
+            return object;
+        };
+
+        object.emit = function (event) {
+            var toNotify = supervisors(this);
+            var args = slice.call(arguments), i, l;
+
+            for (i = 0, l = toNotify.length; i < l; ++i) {
+                notifyListener(event, toNotify[i], args);
+            }
+
+            toNotify = listeners(this, event).slice();
+            args = slice.call(arguments, 1);
+            for (i = 0, l = toNotify.length; i < l; ++i) {
+                notifyListener(event, toNotify[i], args);
+            }
+        };
+
+        object.errback = function (listener) {
+            if (!this.errbacks) { this.errbacks = []; }
+            this.errbacks.push(assertFunction(listener));
+        };
+
+        return object;
+    }
+
+    return {
+        createEventEmitter: createEventEmitter,
+        aggregate: function (emitters) {
+            var aggregate = createEventEmitter();
+            emitters.forEach(function (emitter) {
+                emitter.on(function (event, data) {
+                    aggregate.emit(event, data);
+                });
+            });
+            return aggregate;
+        }
+    };
+});

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

@@ -142,7 +142,8 @@ var buster = (function (setTimeout, B) {
         }
     };
 
-    if (typeof process === "object") {
+    if (typeof process === "object" &&
+        typeof require === "function" && typeof module === "object") {
         var crypto = require("crypto");
         var path = require("path");
 
@@ -188,18 +189,18 @@ var buster = (function (setTimeout, B) {
         };
     } else {
         // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/filter
-        buster.filter = function (fn, thisp) {
+        buster.filter = function (arr, fn, thisp) {
             "use strict";
-            if (this == null) { throw new TypeError(); }
+            if (arr == null) { throw new TypeError(); }
 
-            var t = Object(this);
+            var t = Object(arr);
             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
+                    var val = t[i];
                     if (fn.call(thisp, val, i, t)) { res.push(val); }
                 }
             }

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

@@ -1,63 +1,67 @@
-if (typeof module == "object" && typeof require == "function") {
-    var buster = require("buster-core");
-    buster.assertions = require("../buster-assertions");
-}
+((typeof define === "function" && define.amd && function (m) {
+    define("expect", ["lodash"], m);
+}) || (typeof module === "object" && function (m) {
+    module.exports = m(require("lodash"));
+}) || function (m) { this.expect = m(this._); }
+)(function (_) {
+    var expectation = {};
+    function F() {}
+    var create = function (object) { F.prototype = object; return new F(); };
 
-(function (ba) {
-    ba.expectation = {};
-
-    ba.expect = function (actual) {
-        var expectation = buster.extend(buster.create(ba.expectation), {
+    var expect = function (actual) {
+        var expectation = _.extend(create(expect.expectation), {
             actual: actual,
             assertMode: true
         });
-        expectation.not = buster.create(expectation);
+        expectation.not = 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));
+    expect.expectation = expectation;
+
+    expect.wrapAssertion = function (assertion, expectation, referee) {
+        expect.expectation[expectation] = function () {
+            var args = [this.actual].concat(_.toArray(arguments));
             var type = this.assertMode ? "assert" : "refute";
             var callFunc;
 
             if (assertion === "assert") {
-                callFunc = this.assertMode ? ba.assert : ba.refute;
+                callFunc = this.assertMode ? referee.assert : referee.refute;
             } else if (assertion === "refute") {
-                callFunc = this.assertMode ? ba.refute : ba.assert;
+                callFunc = this.assertMode ? referee.refute : referee.assert;
             } else {
-                callFunc = ba[type][assertion];
+                callFunc = referee[type][assertion];
             }
 
             try {
-                return callFunc.apply(ba.expect, args);
+                return callFunc.apply(referee.expect, args);
             } catch (e) {
                 e.message = (e.message || "").replace(
                     "[" + type + "." + assertion + "]",
-                    "[expect." + (this.assertMode ? "" : "not.") + expectation + "]");
+                    "[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);
-        }
-    }
+    expect.init = function (referee) {
+        _.each(_.keys(referee.assert), function (name) {
+            var expectationName = referee.assert[name].expectationName;
+            if (expectationName) {
+                expect.wrapAssertion(name, expectationName, referee);
+            }
+        });
 
-    ba.expect.wrapAssertion("assert", "toBeTruthy");
-    ba.expect.wrapAssertion("refute", "toBeFalsy");
+        expect.wrapAssertion("assert", "toBeTruthy", referee);
+        expect.wrapAssertion("refute", "toBeFalsy", referee);
 
-    if (ba.expectation.toBeNear) {
-        ba.expectation.toBeCloseTo = ba.expectation.toBeNear;
-    }
+        if (expect.expectation.toBeNear) {
+            expect.expectation.toBeCloseTo = expect.expectation.toBeNear;
+        }
+    };
 
-    if (typeof module == "object") {
-        module.exports = ba.expect;
-    }
-}(buster.assertions));
+    return expect;
+});

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

@@ -0,0 +1,215 @@
+((typeof define === "function" && define.amd && function (m) {
+    define("formatio", ["samsam"], m);
+}) || (typeof module === "object" && function (m) {
+    module.exports = m(require("samsam"));
+}) || function (m) { this.formatio = m(this.samsam); }
+)(function (samsam) {
+    "use strict";
+
+    var formatio = {
+        excludeConstructors: ["Object", /^.$/],
+        quoteStrings: true,
+        limitChildrenCount: 0
+    };
+
+    var hasOwn = Object.prototype.hasOwnProperty;
+
+    var specialObjects = [];
+    if (typeof global !== "undefined") {
+        specialObjects.push({ object: global, value: "[object global]" });
+    }
+    if (typeof document !== "undefined") {
+        specialObjects.push({
+            object: document,
+            value: "[object HTMLDocument]"
+        });
+    }
+    if (typeof window !== "undefined") {
+        specialObjects.push({ object: window, value: "[object Window]" });
+    }
+
+    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]) || "";
+    }
+
+    function constructorName(f, object) {
+        var name = functionName(object && object.constructor);
+        var excludes = f.excludeConstructors ||
+                formatio.excludeConstructors || [];
+
+        var i, l;
+        for (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;
+    }
+
+    function isCircular(object, objects) {
+        if (typeof object !== "object") { return false; }
+        var i, l;
+        for (i = 0, l = objects.length; i < l; ++i) {
+            if (objects[i] === object) { return true; }
+        }
+        return false;
+    }
+
+    function ascii(f, object, processed, indent) {
+        if (typeof object === "string") {
+            if (object.length === 0) { return "(empty string)"; }
+            var qs = f.quoteStrings;
+            var quote = typeof qs !== "boolean" || qs;
+            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(f, object, processed);
+        }
+
+        if (!object) { return String((1/object) === -Infinity ? "-0" : object); }
+        if (samsam.isElement(object)) { return ascii.element(object); }
+
+        if (typeof object.toString === "function" &&
+                object.toString !== Object.prototype.toString) {
+            return object.toString();
+        }
+
+        var i, l;
+        for (i = 0, l = specialObjects.length; i < l; i++) {
+            if (object === specialObjects[i].object) {
+                return specialObjects[i].value;
+            }
+        }
+
+        return ascii.object.call(f, object, processed, indent);
+    }
+
+    ascii.func = function (func) {
+        return "function " + functionName(func) + "() {}";
+    };
+
+    ascii.array = function (array, processed) {
+        processed = processed || [];
+        processed.push(array);
+        var pieces = [];
+        var i, l;
+        l = (this.limitChildrenCount > 0) ? 
+            Math.min(this.limitChildrenCount, array.length) : array.length;
+
+        for (i = 0; i < l; ++i) {
+            pieces.push(ascii(this, array[i], processed));
+        }
+
+        if(l < array.length)
+            pieces.push("[... " + (array.length - l) + " more elements]");
+
+        return "[" + pieces.join(", ") + "]";
+    };
+
+    ascii.object = function (object, processed, indent) {
+        processed = processed || [];
+        processed.push(object);
+        indent = indent || 0;
+        var pieces = [], properties = samsam.keys(object).sort();
+        var length = 3;
+        var prop, str, obj, i, k, l;
+        l = (this.limitChildrenCount > 0) ? 
+            Math.min(this.limitChildrenCount, properties.length) : properties.length;
+
+        for (i = 0; i < l; ++i) {
+            prop = properties[i];
+            obj = object[prop];
+
+            if (isCircular(obj, processed)) {
+                str = "[Circular]";
+            } else {
+                str = ascii(this, obj, processed, indent + 2);
+            }
+
+            str = (/\s/.test(prop) ? '"' + prop + '"' : prop) + ": " + str;
+            length += str.length;
+            pieces.push(str);
+        }
+
+        var cons = constructorName(this, object);
+        var prefix = cons ? "[" + cons + "] " : "";
+        var is = "";
+        for (i = 0, k = indent; i < k; ++i) { is += " "; }
+
+        if(l < properties.length)
+            pieces.push("[... " + (properties.length - l) + " more elements]");
+
+        if (length + indent > 80) {
+            return prefix + "{\n  " + is + pieces.join(",\n  " + is) + "\n" +
+                is + "}";
+        }
+        return prefix + "{ " + pieces.join(", ") + " }";
+    };
+
+    ascii.element = function (element) {
+        var tagName = element.tagName.toLowerCase();
+        var attrs = element.attributes, attr, pairs = [], attrName, i, l, val;
+
+        for (i = 0, l = attrs.length; i < l; ++i) {
+            attr = attrs.item(i);
+            attrName = attr.nodeName.toLowerCase().replace("html:", "");
+            val = attr.nodeValue;
+            if (attrName !== "contenteditable" || val !== "inherit") {
+                if (!!val) { pairs.push(attrName + "=\"" + val + "\""); }
+            }
+        }
+
+        var formatted = "<" + tagName + (pairs.length > 0 ? " " : "");
+        // SVG elements have undefined innerHTML
+        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"/, "");
+    };
+
+    function Formatio(options) {
+        for (var opt in options) {
+            this[opt] = options[opt];
+        }
+    }
+
+    Formatio.prototype = {
+        functionName: functionName,
+
+        configure: function (options) {
+            return new Formatio(options);
+        },
+
+        constructorName: function (object) {
+            return constructorName(this, object);
+        },
+
+        ascii: function (object, processed, indent) {
+            return ascii(this, object, processed, indent);
+        }
+    };
+
+    return Formatio.prototype;
+});