shuriken 0.1.2.2 → 0.1.3

data/.gitignore

@@ -0,0 +1 @@
+test-output

data/Rakefile

@@ -18,3 +18,31 @@ begin
 rescue LoadError
   puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
 end
+
+desc "Compiles the javascript from Coffeescript to Javascript"
+task :compile_scripts do
+  Dir["coffeescripts/**/*.coffee"].each do |cs|
+    output = File.dirname(cs).gsub("coffeescripts", "javascripts")
+    system "coffee", "-c", "--no-wrap", cs, "-o", output
+  end
+end
+
+task :test => :compile_scripts do
+  require 'erb'
+  template = ERB.new(File.read("tests/template.erb"))
+  FileUtils.mkdir_p 'test-output'
+  FileUtils.rm_rf   'test-output/*'
+  Dir["tests/*.coffee"].each do |test|
+    test_name = File.basename(test, ".coffee")
+    $js_file = "#{test_name}.js"
+    File.open("test-output/#{test_name}.html", "w+") do |f|
+      f.write template.result
+    end
+    $js_file = nil
+    system "coffee", "-c", "--no-wrap", test, "-o", "test-output"
+  end
+end
+
+task :watchr do
+  system "watchr tests.watchr"
+end

data/coffeescripts/shuriken/test/assertions.coffee

@@ -0,0 +1,111 @@
+# General assertions.
+Shuriken.Test.Assertions: ((ns) ->
+  
+  ns.currentAssertionCatcher: null
+  
+  class ns.AssertionCatcher
+    
+    constructor: ->
+      @passedCount:    0
+      @passedMessages: []
+      @failedOn:       null
+      
+    failAssertion: (e) ->
+      @failedOn: e
+      
+    passAssertion: (e) ->
+      @passedMessages.push e.message
+      @passedCount++
+      
+    failedReason: ->
+      return "Not failed" if !@failedOn?
+      @failedOn.toString()
+      
+    passed: -> not @failed()
+    
+    failed: -> @failedOn?
+      
+  
+  class ns.AssertionFailed
+    
+    constructor: (message) ->
+      @message: message
+      
+    toString: ->
+      "Assertion Failed: $@message"
+  
+  ns.assert: (condition, message) ->
+    if condition
+      # TODO: Track in some sort of test scope.
+      console.log "Assertion passed: $message"
+    else
+      throw new ns.AssertionFailed message
+  
+  ns.assertEqual: (expected, actual, message) ->
+    message?= "Expected $actual, got $expected."
+    ns.assert actual is expected, message
+  
+  ns.assertBlock: (message, block) ->
+    if typeof message is "function"
+      block: message
+      message: "expected block to return true"
+    ns.assert block(), message
+  
+  ns.assertInDelta: (expected, actual, delta, message) ->
+    message?= "expected $actual and $expected to be within $delta of each other."
+    ns.assert Math.abs(expected - actual) <= delta, message
+  
+  ns.assertTypeOf: (expected, object, message) ->
+    message?= "Expected the type of $object to be $expected"
+    ns.assert (typeof object is expected), message
+    
+  ns.assertTypeOfIsnt: (expected, object, message) ->
+    message?= "Expected the type of $object to not be $expected"
+    ns.assert (typeof object isnt expected), message
+  
+  ns.assertInstanceOf: (expected, object, message) ->
+    message?= "Expected $object to be an instance of $expected"
+    ns.assert (object instanceof expected), message
+    
+  ns.assertUndefined: (object, message) ->
+    message?= "Expected $object to be undefined"
+    ns.assertTypeOf 'undefined', object, message
+  
+  ns.assertDefined: (object, message) ->
+    message?= "Expected $object to be defined"
+    ns.assertTypeOfIsnt 'undefined', object, message
+    
+  ns.assertNotEqual: (expected, object, message) ->
+    message?= "Expected $object not to equal $expected"
+    ns.assert object isnt expected, message
+    
+  ns.assertNull: (object, message) ->
+    message?= "Expected $object to be null"
+    ns.assert object is null, message
+    
+  ns.assertNotNull: (object, message) ->
+    message?= "Expected $object to not be null"
+    ns.assert object isnt null, message
+    
+  ns.flunk: (message) ->
+    message?= "Flunking test for no reason"
+    ns.assert false, "Flunk: $message"
+  
+)({})
+
+Shuriken.Test.withAssertions: (closure) ->
+  `with(Shuriken.Test.Assertions) { closure() }`
+  
+Shuriken.Test.catchingAssertions: (closure) ->
+  ac: Shuriken.Test.AssertionCatcher
+  catcher: new ac()
+  old: ac.currentAssertionCatcher
+  ac.currentAssertionCatcher: catcher
+  try
+    closure()
+  catch e
+    catcher.failAssertion e
+  finally
+    ac.currentAssertionCatcher: old
+  catcher
+  

data/coffeescripts/shuriken/test/reporters.coffee

@@ -0,0 +1,61 @@
+Shuriken.Test.Reporters: {}
+
+((reporters) ->
+  
+  class reporters.Reporter
+    
+    constructor: (results) ->
+      @results: results
+      
+    showResults: () -> throw "Please us an implemented reporter."
+    
+  class reporters.ConsoleReporter extends reporters.Reporter
+    
+    showResults: (results, padding) ->
+      results?= @results
+      padding?= 0
+      if $.isArray @results
+        # A
+      else if @results instanceof Shuriken.Test.ContextResult
+        # B
+      else if @results instanceof Shuriken.Test.AssertionCatcher
+        # C
+      
+    puts: (args...) -> console.log('[Shuriken.Test.Reporters.ConsoleReporter]', args...)
+    
+    paddedPuts: (padding, args...) ->
+      padding
+      
+    
+    showContext: (cr, padding) ->
+      padding?= 0
+      context: cr.context
+      @paddedPuts padding, "Context: $context.name"
+      @showResults cr.results, padding + 2
+    
+    showTest: (tr, padding) ->
+      padding?= 0
+      assertions: tr.assertions
+      if assertions.failed()
+        @paddedPuts padding, "[\u2718]", tr.test.name, "(${assertions.failedReason()})"
+      else if assertions.passed() and assertions.passedCount > 0
+        @paddedPuts padding, "[\u2714]", tr.test.name
+      else
+        @paddedPuts padding, "[\u203D]", tr.test.name, "(Pending)"
+      
+    showArray: (array, padding) ->
+      padding?= 0
+      lastIndex: array.length - 1
+      for i in [0..lastIndex]
+        @showResults array[i], padding
+        @paddedPuts padding, "" unless i == lastIndex
+      
+    
+  # Set the current reporter.
+  reporters.current: reporters.ConsoleReporter
+      
+  Shuriken.Test.displayResults: (results) ->
+    reporter: new reporters.current results
+    reporter.showResults()
+
+)(Shuriken.Test.Reporters)

data/coffeescripts/shuriken/test.coffee

@@ -0,0 +1,117 @@
+Shuriken.Test = {
+  currentContext: []
+}
+
+Shuriken.withObject: (object, block) ->
+  `with(object) { block.apply(object); }`
+
+((test) ->
+
+  class test.ContextResult
+    
+    constructor: (context, results) ->
+      @context: context
+      @results: results
+
+  class test.TestResult
+
+    constructor: (test, assertions) ->
+      @test: test
+      @assertions: assertions
+
+  class test.Context
+    
+    constructor: (name, context) ->
+      @name:   name
+      @blocks: {}
+      @context: context
+    
+    blocksFor: (name) ->
+      @blocks[name]?= []
+      
+    addBlockFor: (name, block) ->
+      @blocksFor(name).push block
+    
+    run: ->
+      scope: @toScope()
+      @context.invokeBlocksFor "setupAll", scope if @context?
+      @invokeBlocksFor "setupAll", scope
+      # Invoke all stuff.
+      results: []
+      Shuriken.withObject @, -> results: @invokeBlocksFor("inner", scope)
+      @invokeBlocksFor "teardownAll", scope
+      @context.invokeBlocksFor "teardownAll", scope if @context?
+      new test.ContextResult @, results
+      
+    toScope: ->
+      return @scope if @scope?
+      scope: ->
+      scope.prototype: @context.toScope() if @context?
+      self: @
+      @scope: new scope()
+      @scope.setup: ->
+        superSetup: scope::setup
+        superSetup.apply(@) if superSetup?
+        self.invokeBlocksFor "setup", @
+      @scope.teardown: ->
+        superSetup: scope::teardown
+        superSetup.apply(@) if superTeardown?
+        self.invokeBlocksFor "teardown", @
+        
+    invokeBlocksFor: (blockName, scope) ->
+      block.apply(scope) for block in @blocksFor(blockNmae)
+    
+    setup:       (c) -> @addBlockFor "setup",       c
+    teardown:    (c) -> @addBlockFor "teardown",    c
+    setupAll:    (c) -> @addBlockFor "setupAll",    c
+    teardownAll: (c) -> @addBlockFor "teardownAll", c
+      
+    context: (name, block) ->
+      context: new test.Context name, @
+      block.apply context
+      addBlockFor 'inner', -> context.run
+      
+    should: (name, block) ->
+      test: new test.Test name, block, @
+      addBlockFor 'inner', -> test.run
+      
+  class test.Test
+    
+    constructor: (name, body, context) ->
+      @name:    name
+      @body:    body
+      @context: context
+      
+    run: ->
+      scope = @toScope()
+      scope.setup()
+      result: Shuriken.Test.catchingAssertions -> @body.apply scope
+      scope.teardown()
+      new test.TestResult @, result
+      
+    toScope: ->
+      scope: ->
+      scope.prototype: @context
+      scope: new scope()
+      
+  
+  test.displayResults: (results) ->
+    # Do nothing at the moment...
+  
+  test.testsFor: (name, block) ->
+    context: new test.Context name
+    test.tests[name]: context
+    Shuriken.withObject context, block
+    context.runSuite: ->
+      results: @run()
+      test.displayResults results
+      
+  test.tests: {}
+  
+  test.runAll: ->
+    results: test.run() for test in test.tests when test.runSuite?
+    test.displayResults results
+    
+  test 
+
+)(Shuriken.Test)

data/coffeescripts/shuriken.coffee

@@ -35,8 +35,8 @@
   base.toNSName: (children...) ->
     parts: children
     current: @
-    while current.parent?
-      parts.unshift parts
+    while current?
+      parts.unshift current.name
       current: current.parent
     parts.join "."
   

data/javascripts/shuriken/mixins/callbacks.js

@@ -0,0 +1,45 @@
+var __slice = Array.prototype.slice;
+Shuriken.defineExtension(function(baseNS) {
+  return baseNS.defineMixin('Callbacks', function(mixin) {
+    mixin.callbacks = {};
+    mixin.defineCallback = function defineCallback(key) {
+      this[("on" + key)] = function(callback) {
+        return this.hasCallback(key, callback);
+      };
+      this[("invoke" + key)] = function() {
+        var args;
+        args = __slice.call(arguments, 0, arguments.length - 0);
+        return this.invokeCallbacks.apply(this, [key].concat(args));
+      };
+      return true;
+    };
+    mixin.hasCallback = function hasCallback(name, callback) {
+      var _a, callbacks;
+      callbacks = mixin.callbacks[name] = (typeof (_a = mixin.callbacks[name]) !== "undefined" && _a !== null) ? mixin.callbacks[name] : [];
+      callbacks.push(callback);
+      return true;
+    };
+    mixin.callbacksFor = function callbacksFor(name) {
+      var existing;
+      existing = mixin.callbacks[name];
+      if ((typeof existing !== "undefined" && existing !== null)) {
+        return existing;
+      } else {
+        return [];
+      }
+    };
+    mixin.invokeCallbacks = function invokeCallbacks(name) {
+      var _a, _b, _c, args, callback;
+      args = __slice.call(arguments, 1, arguments.length - 0);
+      _b = mixin.callbacksFor(name);
+      for (_a = 0, _c = _b.length; _a < _c; _a++) {
+        callback = _b[_a];
+        if (callback.apply(this, args) === false) {
+          return false;
+        }
+      }
+      return true;
+    };
+    return mixin.invokeCallbacks;
+  });
+});

data/javascripts/shuriken/mixins.js

@@ -0,0 +1,58 @@
+Shuriken.defineExtension(function(baseNS) {
+  return baseNS.withNS('Mixins', function(ns) {
+    var defineMixin, root;
+    root = this.getRootNS();
+    ns.mixins = {};
+    root.mixins = {};
+    root.withBase(function(base) {
+      base.mixin = function mixin(mixins) {
+        return ns.mixin(this, mixins);
+      };
+      return base.mixin;
+    });
+    defineMixin = function defineMixin(key, mixin) {
+      this.mixins[key] = mixin;
+      return this.mixins[key];
+    };
+    root.defineMixin = defineMixin;
+    ns.define = defineMixin;
+    ns.lookupMixin = function lookupMixin(mixin) {
+      var _a, _b, _c;
+      if ((_a = typeof mixin) === "string") {
+        if ((typeof (_b = ns.mixins[mixin]) !== "undefined" && _b !== null)) {
+          return ns.mixins[mixin];
+        } else if ((typeof (_c = root.mixins[mixin]) !== "undefined" && _c !== null)) {
+          return root.mixins[mixin];
+        } else {
+          return {};
+          // unknown mixin, return a blank object.
+        }
+      } else {
+        return mixin;
+      }
+    };
+    ns.invokeMixin = function invokeMixin(scope, mixin) {
+      var _a;
+      if ((_a = typeof mixin) === "string") {
+        return ns.invokeMixin(scope, ns.lookupMixin(mixin));
+      } else if (_a === "function") {
+        return mixin.call(scope, scope);
+      } else if (_a === "object") {
+        return $.extend(scope, mixin);
+      }
+    };
+    ns.mixin = function mixin(scope, mixins) {
+      var _a, _b, _c, mixin;
+      if (!($.isArray(mixins))) {
+        mixins = [mixins];
+      }
+      _b = mixins;
+      for (_a = 0, _c = _b.length; _a < _c; _a++) {
+        mixin = _b[_a];
+        ns.invokeMixin(scope, ns.lookupMixin(mixin));
+      }
+      return true;
+    };
+    return ns.mixin;
+  });
+});

data/javascripts/shuriken/test/assertions.js

@@ -0,0 +1,117 @@
+// General assertions.
+Shuriken.Test.Assertions = (function(ns) {
+  ns.currentAssertionCatcher = null;
+  ns.AssertionCatcher = function AssertionCatcher() {
+    this.passedCount = 0;
+    this.passedMessages = [];
+    this.failedOn = null;
+    return this;
+  };
+  ns.AssertionCatcher.prototype.failAssertion = function failAssertion(e) {
+    this.failedOn = e;
+    return this.failedOn;
+  };
+  ns.AssertionCatcher.prototype.passAssertion = function passAssertion(e) {
+    this.passedMessages.push(e.message);
+    return this.passedCount++;
+  };
+  ns.AssertionCatcher.prototype.failedReason = function failedReason() {
+    var _a;
+    if (!(typeof (_a = this.failedOn) !== "undefined" && _a !== null)) {
+      return "Not failed";
+    }
+    return this.failedOn.toString();
+  };
+  ns.AssertionCatcher.prototype.passed = function passed() {
+    return !this.failed();
+  };
+  ns.AssertionCatcher.prototype.failed = function failed() {
+    var _a;
+    return (typeof (_a = this.failedOn) !== "undefined" && _a !== null);
+  };
+  ns.AssertionFailed = function AssertionFailed(message) {
+    this.message = message;
+    return this;
+  };
+  ns.AssertionFailed.prototype.toString = function toString() {
+    return "Assertion Failed: " + this.message;
+  };
+  ns.assert = function assert(condition, message) {
+    if (condition) {
+      // TODO: Track in some sort of test scope.
+      return console.log(("Assertion passed: " + message));
+    } else {
+      throw new ns.AssertionFailed(message);
+    }
+  };
+  ns.assertEqual = function assertEqual(expected, actual, message) {
+    message = (typeof message !== "undefined" && message !== null) ? message : ("Expected " + actual + ", got " + expected + ".");
+    return ns.assert(actual === expected, message);
+  };
+  ns.assertBlock = function assertBlock(message, block) {
+    if (typeof message === "function") {
+      block = message;
+      message = "expected block to return true";
+    }
+    return ns.assert(block(), message);
+  };
+  ns.assertInDelta = function assertInDelta(expected, actual, delta, message) {
+    message = (typeof message !== "undefined" && message !== null) ? message : ("expected " + actual + " and " + expected + " to be within " + delta + " of each other.");
+    return ns.assert(Math.abs(expected - actual) <= delta, message);
+  };
+  ns.assertTypeOf = function assertTypeOf(expected, object, message) {
+    message = (typeof message !== "undefined" && message !== null) ? message : ("Expected the type of " + object + " to be " + expected);
+    return ns.assert((typeof object === expected), message);
+  };
+  ns.assertTypeOfIsnt = function assertTypeOfIsnt(expected, object, message) {
+    message = (typeof message !== "undefined" && message !== null) ? message : ("Expected the type of " + object + " to not be " + expected);
+    return ns.assert((typeof object !== expected), message);
+  };
+  ns.assertInstanceOf = function assertInstanceOf(expected, object, message) {
+    message = (typeof message !== "undefined" && message !== null) ? message : ("Expected " + object + " to be an instance of " + expected);
+    return ns.assert((object instanceof expected), message);
+  };
+  ns.assertUndefined = function assertUndefined(object, message) {
+    message = (typeof message !== "undefined" && message !== null) ? message : ("Expected " + object + " to be undefined");
+    return ns.assertTypeOf('undefined', object, message);
+  };
+  ns.assertDefined = function assertDefined(object, message) {
+    message = (typeof message !== "undefined" && message !== null) ? message : ("Expected " + object + " to be defined");
+    return ns.assertTypeOfIsnt('undefined', object, message);
+  };
+  ns.assertNotEqual = function assertNotEqual(expected, object, message) {
+    message = (typeof message !== "undefined" && message !== null) ? message : ("Expected " + object + " not to equal " + expected);
+    return ns.assert(object !== expected, message);
+  };
+  ns.assertNull = function assertNull(object, message) {
+    message = (typeof message !== "undefined" && message !== null) ? message : ("Expected " + object + " to be null");
+    return ns.assert(object === null, message);
+  };
+  ns.assertNotNull = function assertNotNull(object, message) {
+    message = (typeof message !== "undefined" && message !== null) ? message : ("Expected " + object + " to not be null");
+    return ns.assert(object !== null, message);
+  };
+  ns.flunk = function flunk(message) {
+    message = (typeof message !== "undefined" && message !== null) ? message : "Flunking test for no reason";
+    return ns.assert(false, ("Flunk: " + message));
+  };
+  return ns.flunk;
+})({});
+Shuriken.Test.withAssertions = function withAssertions(closure) {
+  return with(Shuriken.Test.Assertions) { closure() };
+};
+Shuriken.Test.catchingAssertions = function catchingAssertions(closure) {
+  var ac, catcher, old;
+  ac = Shuriken.Test.AssertionCatcher;
+  catcher = new ac();
+  old = ac.currentAssertionCatcher;
+  ac.currentAssertionCatcher = catcher;
+  try {
+    closure();
+  } catch (e) {
+    catcher.failAssertion(e);
+  } finally {
+    ac.currentAssertionCatcher = old;
+  }
+  return catcher;
+};

data/javascripts/shuriken/test/reporters.js

@@ -0,0 +1,84 @@
+var __slice = Array.prototype.slice, __extends = function(child, parent) {
+    var ctor = function(){ };
+    ctor.prototype = parent.prototype;
+    child.__superClass__ = parent.prototype;
+    child.prototype = new ctor();
+    child.prototype.constructor = child;
+  };
+Shuriken.Test.Reporters = {};
+(function(reporters) {
+  reporters.Reporter = function Reporter(results) {
+    this.results = results;
+    return this;
+  };
+  reporters.Reporter.prototype.showResults = function showResults() {
+    throw "Please us an implemented reporter.";
+  };
+  reporters.ConsoleReporter = function ConsoleReporter() {
+    return reporters.Reporter.apply(this, arguments);
+  };
+  __extends(reporters.ConsoleReporter, reporters.Reporter);
+  reporters.ConsoleReporter.prototype.showResults = function showResults(results, padding) {
+    results = (typeof results !== "undefined" && results !== null) ? results : this.results;
+    padding = (typeof padding !== "undefined" && padding !== null) ? padding : 0;
+    if ($.isArray(this.results)) {
+      // A
+    } else if (this.results instanceof Shuriken.Test.ContextResult) {
+      // B
+    } else if (this.results instanceof Shuriken.Test.AssertionCatcher) {
+      // C
+    }
+  };
+  reporters.ConsoleReporter.prototype.puts = function puts() {
+    var args;
+    args = __slice.call(arguments, 0, arguments.length - 0);
+    return console.log.apply(console, ['[Shuriken.Test.Reporters.ConsoleReporter]'].concat(args));
+  };
+  reporters.ConsoleReporter.prototype.paddedPuts = function paddedPuts(padding) {
+    var args;
+    args = __slice.call(arguments, 1, arguments.length - 0);
+    return padding;
+  };
+  reporters.ConsoleReporter.prototype.showContext = function showContext(cr, padding) {
+    var context;
+    padding = (typeof padding !== "undefined" && padding !== null) ? padding : 0;
+    context = cr.context;
+    this.paddedPuts(padding, ("Context: " + context.name));
+    return this.showResults(cr.results, padding + 2);
+  };
+  reporters.ConsoleReporter.prototype.showTest = function showTest(tr, padding) {
+    var assertions;
+    padding = (typeof padding !== "undefined" && padding !== null) ? padding : 0;
+    assertions = tr.assertions;
+    if (assertions.failed()) {
+      return this.paddedPuts(padding, "[\u2718]", tr.test.name, ("(" + (assertions.failedReason()) + ")"));
+    } else if (assertions.passed() && assertions.passedCount > 0) {
+      return this.paddedPuts(padding, "[\u2714]", tr.test.name);
+    } else {
+      return this.paddedPuts(padding, "[\u203D]", tr.test.name, "(Pending)");
+    }
+  };
+  reporters.ConsoleReporter.prototype.showArray = function showArray(array, padding) {
+    var _a, _b, _c, _d, i, lastIndex;
+    padding = (typeof padding !== "undefined" && padding !== null) ? padding : 0;
+    lastIndex = array.length - 1;
+    _a = []; _c = 0; _d = lastIndex;
+    for (_b = 0, i = _c; (_c <= _d ? i <= _d : i >= _d); (_c <= _d ? i += 1 : i -= 1), _b++) {
+      _a.push((function() {
+        this.showResults(array[i], padding);
+        if (!(i === lastIndex)) {
+          return this.paddedPuts(padding, "");
+        }
+      }).call(this));
+    }
+    return _a;
+  };
+  // Set the current reporter.
+  reporters.current = reporters.ConsoleReporter;
+  Shuriken.Test.displayResults = function displayResults(results) {
+    var reporter;
+    reporter = new reporters.current(results);
+    return reporter.showResults();
+  };
+  return Shuriken.Test.displayResults;
+})(Shuriken.Test.Reporters);