konacha 0.9.0

data/spec/dummy/spec/javascripts/subdirectory/subdirectory_spec.js

@@ -0,0 +1,5 @@
+describe("spec in subdirectory", function(){
+  it("passes", function(){
+    (2 + 2).should.equal(4);
+  });
+});

data/spec/dummy/spec/javascripts/templates/hello.jst.ejs

@@ -0,0 +1 @@
+<h1>Hello Konacha!</h1>

data/spec/dummy/spec/javascripts/templating_spec.js

@@ -0,0 +1,8 @@
+//= require spec_helper
+
+describe("templating", function(){
+  it("is built in to Sprockets", function(){
+    $('#test').html(JST['templates/hello']());
+    $('#test h1').text().should.equal('Hello Konacha!');
+  });
+});

data/spec/dummy/spec/javascripts/transactions_spec.js.coffee

@@ -0,0 +1,7 @@
+describe "transactions", ->
+  it "should add stuff in one test...", ->
+    $('#test').append('<h1 id="added">New Stuff</h1>')
+    $('#test h1#added').length.should.equal(1)
+
+  it "... should have been removed before the next starts", ->
+    $('#test h1#added').length.should.equal(0)

data/spec/konacha_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Konacha do
+  describe ".config" do
+    subject { Konacha.config }
+
+    describe ".interface" do
+      it "defaults to :bdd interface" do
+        subject.interface.should == :bdd
+      end
+    end
+
+    describe ".spec_dir" do
+      it "defaults to 'spec/javascripts'" do
+        subject.spec_dir.should == "spec/javascripts"
+      end
+    end
+  end
+
+  describe ".spec_paths" do
+    subject { Konacha.spec_paths }
+
+    it "returns an array of paths relative to spec_dir" do
+      subject.should include("array_sum_js_spec.js")
+      subject.should include("array_sum_cs_spec.js.coffee")
+    end
+
+    it "includes subdirectories" do
+      subject.should include("subdirectory/subdirectory_spec.js")
+    end
+
+    it "does not include spec_helper" do
+      subject.should_not include("spec_helper.js")
+    end
+  end
+
+  it "can be configured in an initializer" do
+    Konacha.config.configured.should == true
+  end
+end

data/spec/models/spec_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Konacha::Spec do
+  describe "#basename" do
+    it "is the basename of the path" do
+      described_class.new("array_spec.js").basename.should == "array_spec"
+    end
+
+    it "ignores multiple extensions" do
+      described_class.new("array_spec.js.coffee").basename.should == "array_spec"
+    end
+
+    it "includes relative path" do
+      described_class.new("subdirectory/array_spec.js").basename.should == "subdirectory/array_spec"
+    end
+  end
+
+  describe "#url" do
+    it "returns a URL path" do
+      described_class.new("array_spec.js").url.should == "/array_spec"
+    end
+  end
+
+  describe ".all" do
+    it "returns an array of specs" do
+      Konacha.should_receive(:spec_paths) { ["a_spec.js", "b_spec.js"] }
+      all = described_class.all
+      all.length.should == 2
+    end
+  end
+
+  describe ".find" do
+    it "returns the Spec with the given basename" do
+      all = [described_class.new("a_spec.js"),
+             described_class.new("b_spec.js")]
+      described_class.should_receive(:all) { all }
+      described_class.find("b_spec").should == all[1]
+    end
+
+    it "returns nil if no such spec exists" do
+      described_class.should_receive(:all) { [] }
+      described_class.find("b_spec").should be_nil
+    end
+  end
+end

data/spec/runner_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Konacha::Runner do
+  before do
+    Konacha.mode = :runner
+    Konacha.config.driver = :selenium_with_firebug
+  end
+
+  let(:runner) { Konacha::Runner.new(:output => buffer) }
+  let(:buffer) { StringIO.new }
+
+  describe "#run" do
+    before { runner.run }
+
+    it "prints results to the output" do
+      buffer.rewind
+      results = buffer.read
+      results.should include(".......F.....")
+      results.should include("expected 4 to equal 5")
+      results.should include("13 examples, 1 failure")
+    end
+  end
+
+  describe "#run_spec" do
+    let(:spec) { Konacha::Spec.find("failing_spec") }
+    before { runner.spec_runner(spec).run }
+
+    it "prints results to the output" do
+      buffer.rewind
+      results = buffer.read
+      results.should include('F')
+      results.should include("expected 4 to equal 5")
+      results.should include("1 examples, 1 failures")
+    end
+  end
+end

data/spec/server_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Konacha::Server, :type => :request do
+  def app
+    Konacha.application
+  end
+
+  before do
+    Konacha.mode = :server
+  end
+
+  it "serves a root page" do
+    visit "/"
+    page.should have_content("Array#sum (js)")
+    page.should have_css(".test.pass")
+  end
+
+  it "serves an individual JavaScript spec" do
+    visit "/array_sum_js_spec"
+    page.should have_content("Array#sum (js)")
+    page.should have_css(".test.pass", :count => 2)
+  end
+
+  it "serves an individual CoffeeScript spec" do
+    visit "/array_sum_cs_spec"
+    page.should have_content("Array#sum (cs)")
+    page.should have_css(".test.pass", :count => 2)
+  end
+
+  it "serves a spec in a subdirectory" do
+    visit "/subdirectory/subdirectory_spec"
+    page.should have_content("spec in subdirectory")
+    page.should have_css(".test.pass")
+  end
+
+  it "supports spec helpers" do
+    visit "/spec_helper_spec"
+    page.should have_content("two_plus_two")
+    page.should have_css(".test.pass")
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+ENV["RAILS_ENV"] = "test"
+
+require File.expand_path("../dummy/config/environment.rb",  __FILE__)
+require "rspec/rails"
+require "rspec/autorun"
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir[Rails.root.join("spec/support/**/*.rb")].each {|f| require f}
+
+require "capybara/rails"
+require "capybara/firebug"
+
+Capybara.configure do |config|
+  config.default_selector = :css
+  config.default_driver   = :selenium_with_firebug
+  config.app              = Konacha.application
+end

data/spec/views/specs/index.html.erb_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe "konacha/specs/index" do
+  it "renders a script tag for each basename in @specs" do
+    a_spec = stub(:basename => "a_spec")
+    b_spec = stub(:basename => "b_spec")
+    assign(:specs, [a_spec, b_spec])
+    render
+    rendered.should have_selector("script[src='/assets/a_spec.js']")
+    rendered.should have_selector("script[src='/assets/b_spec.js']")
+  end
+end

data/spec/views/specs/show.html.erb_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe "konacha/specs/show" do
+  it "renders a script tag for @spec basename" do
+    spec = stub(:basename => "spec")
+    assign(:spec, spec)
+    render
+    rendered.should have_selector("script[src='/assets/spec.js']")
+  end
+end

data/spec/views/specs/specs.html.erb_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe "layouts/konacha/specs" do
+  it "sets up the specified interface" do
+    assign(:interface, :tdd)
+    render
+    rendered.should include('mocha.setup("tdd")')
+  end
+
+  it "includes konacha JS for given mode" do
+    assign(:mode, :runner)
+    render
+    rendered.should have_css("script[src='/assets/konacha/runner.js']")
+  end
+end

data/vendor/assets/javascripts/chai.js

@@ -0,0 +1,2007 @@
+!function (name, definition) {
+  if (typeof define == 'function' && typeof define.amd  == 'object') define(definition);
+  else this[name] = definition();
+}('chai', function () {
+
+// CommonJS require()
+
+function require(p){
+    var path = require.resolve(p)
+      , mod = require.modules[path];
+    if (!mod) throw new Error('failed to require "' + p + '"');
+    if (!mod.exports) {
+      mod.exports = {};
+      mod.call(mod.exports, mod, mod.exports, require.relative(path));
+    }
+    return mod.exports;
+  }
+
+require.modules = {};
+
+require.resolve = function (path){
+    var orig = path
+      , reg = path + '.js'
+      , index = path + '/index.js';
+    return require.modules[reg] && reg
+      || require.modules[index] && index
+      || orig;
+  };
+
+require.register = function (path, fn){
+    require.modules[path] = fn;
+  };
+
+require.relative = function (parent) {
+    return function(p){
+      if ('.' != p[0]) return require(p);
+
+      var path = parent.split('/')
+        , segs = p.split('/');
+      path.pop();
+
+      for (var i = 0; i < segs.length; i++) {
+        var seg = segs[i];
+        if ('..' == seg) path.pop();
+        else if ('.' != seg) path.push(seg);
+      }
+
+      return require(path.join('/'));
+    };
+  };
+
+
+require.register("assertion.js", function(module, exports, require){
+/*!
+ * chai
+ * Copyright(c) 2011 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ *
+ * Primarily a refactor of: should.js
+ * https://github.com/visionmedia/should.js
+ * Copyright(c) 2011 TJ Holowaychuk <tj@vision-media.ca>
+ * MIT Licensed
+ */
+
+/**
+ * ### BDD Style Introduction
+ *
+ * The BDD style is exposed through `expect` or `should` interfaces. In both
+ * scenarios, you chain together natural language assertions.
+ *
+ *      // expect
+ *      var expect = require('chai').expect;
+ *      expect(foo).to.equal('bar');
+ *
+ *      // should
+ *      var should = require('chai').should();
+ *      foo.should.equal('bar');
+ *
+ * #### Differences
+ *
+ * The `expect` interface provides a function as a starting point for chaining
+ * your language assertions. It works on both node.js and in the browser.
+ *
+ * The `should` interface extends `Object.prototype` to provide a single getter as
+ * the starting point for your language assertions. Most browser don't like
+ * extensions to `Object.prototype` so it is not recommended for browser use.
+ */
+
+/*!
+ * Module dependencies.
+ */
+
+var AssertionError = require('./error')
+  , eql = require('./utils/eql')
+  , inspect = require('./utils/inspect');
+
+/*!
+ * Module export.
+ */
+
+module.exports = Assertion;
+
+/*!
+ * # Assertion Constructor
+ *
+ * Creates object for chaining.
+ *
+ * @api private
+ */
+
+function Assertion (obj, msg, stack) {
+  this.ssfi = stack || arguments.callee;
+  this.obj = obj;
+  this.msg = msg;
+}
+
+/*!
+ * # .assert(expression, message, negateMessage)
+ *
+ * Executes an expression and check expectations. Throws AssertionError for reporting if test doesn't pass.
+ *
+ * @name assert
+ * @param {Philosophical} expression to be tested
+ * @param {String} message to display if fails
+ * @param {String} negatedMessage to display if negated expression fails
+ * @api privage
+ */
+
+Assertion.prototype.assert = function (expr, msg, negateMsg) {
+  var msg = (this.negate ? negateMsg : msg)
+    , ok = this.negate ? !expr : expr;
+
+  if (!ok) {
+    throw new AssertionError({
+      operator: this.msg,
+      message: msg,
+      stackStartFunction: this.ssfi
+    });
+  }
+};
+
+/*!
+ * # inspect
+ *
+ * Returns the current object stringified.
+ *
+ * @name inspect
+ * @api private
+ */
+
+Object.defineProperty(Assertion.prototype, 'inspect',
+  { get: function () {
+      return inspect(this.obj);
+    },
+    configurable: true
+});
+
+/**
+ * # to
+ *
+ * Language chain.
+ *
+ * @name to
+ * @api public
+ */
+
+Object.defineProperty(Assertion.prototype, 'to',
+  { get: function () {
+      return this;
+    },
+    configurable: true
+});
+
+/**
+ * # be
+ *
+ * Language chain.
+ *
+ * @name be
+ * @api public
+ */
+
+Object.defineProperty(Assertion.prototype, 'be',
+  { get: function () {
+      return this;
+    },
+    configurable: true
+});
+
+/**
+ * # been
+ *
+ * Language chain. Also tests `tense` to past for addon
+ * modules that use the tense feature.
+ *
+ * @name been
+ * @api public
+ */
+
+Object.defineProperty(Assertion.prototype, 'been',
+  { get: function () {
+      this.tense = 'past';
+      return this;
+    },
+    configurable: true
+});
+
+/**
+ * # an
+ *
+ * Language chain.
+ *
+ * @name an
+ * @api public
+ */
+
+Object.defineProperty(Assertion.prototype, 'an',
+  { get: function () {
+      return this;
+    },
+    configurable: true
+});
+/**
+ * # is
+ *
+ * Language chain.
+ *
+ * @name is
+ * @api public
+ */
+
+Object.defineProperty(Assertion.prototype, 'is',
+  { get: function () {
+      return this;
+    },
+    configurable: true
+});
+
+/**
+ * # and
+ *
+ * Language chain.
+ *
+ * @name and
+ * @api public
+ */
+
+Object.defineProperty(Assertion.prototype, 'and',
+  { get: function () {
+      return this;
+    },
+    configurable: true
+});
+
+/**
+ * # have
+ *
+ * Language chain.
+ *
+ * @name have
+ * @api public
+ */
+
+Object.defineProperty(Assertion.prototype, 'have',
+  { get: function () {
+      return this;
+    },
+    configurable: true
+});
+
+/**
+ * # with
+ *
+ * Language chain.
+ *
+ * @name with
+ * @api public
+ */
+
+Object.defineProperty(Assertion.prototype, 'with',
+  { get: function () {
+      return this;
+    },
+    configurable: true
+});
+
+/**
+ * # .not
+ *
+ * Negates any of assertions following in the chain.
+ *
+ * @name not
+ * @api public
+ */
+
+Object.defineProperty(Assertion.prototype, 'not',
+  { get: function () {
+      this.negate = true;
+      return this;
+    },
+    configurable: true
+});
+
+/**
+ * # .ok
+ *
+ * Assert object truthiness.
+ *
+ *      expect('everthing').to.be.ok;
+ *      expect(false).to.not.be.ok;
+ *      expect(undefined).to.not.be.ok;
+ *      expect(null).to.not.be.ok;
+ *
+ * @name ok
+ * @api public
+ */
+
+Object.defineProperty(Assertion.prototype, 'ok',
+  { get: function () {
+      this.assert(
+          this.obj
+        , 'expected ' + this.inspect + ' to be truthy'
+        , 'expected ' + this.inspect + ' to be falsey');
+
+      return this;
+    },
+    configurable: true
+});
+
+/**
+ * # .true
+ *
+ * Assert object is true
+ *
+ * @name true
+ * @api public
+ */
+
+Object.defineProperty(Assertion.prototype, 'true',
+  { get: function () {
+      this.assert(
+          true === this.obj
+        , 'expected ' + this.inspect + ' to be true'
+        , 'expected ' + this.inspect + ' to be false');
+
+      return this;
+    },
+    configurable: true
+});
+
+/**
+ * # .false
+ *
+ * Assert object is false
+ *
+ * @name false
+ * @api public
+ */
+
+Object.defineProperty(Assertion.prototype, 'false',
+  { get: function () {
+      this.assert(
+          false === this.obj
+        , 'expected ' + this.inspect + ' to be false'
+        , 'expected ' + this.inspect + ' to be true');
+
+      return this;
+    },
+    configurable: true
+});
+
+/**
+ * # .exist
+ *
+ * Assert object exists (null).
+ *
+ *      var foo = 'hi'
+ *        , bar;
+ *      expect(foo).to.exist;
+ *      expect(bar).to.not.exist;
+ *
+ * @name exist
+ * @api public
+ */
+
+Object.defineProperty(Assertion.prototype, 'exist',
+  { get: function () {
+      this.assert(
+          null != this.obj
+        , 'expected ' + this.inspect + ' to exist'
+        , 'expected ' + this.inspect + ' to not exist');
+
+      return this;
+    },
+    configurable: true
+});
+
+/**
+ * # .empty
+ *
+ * Assert object's length to be 0.
+ *
+ *      expect([]).to.be.empty;
+ *
+ * @name empty
+ * @api public
+ */
+
+Object.defineProperty(Assertion.prototype, 'empty',
+  { get: function () {
+      new Assertion(this.obj).to.have.property('length');
+
+      this.assert(
+          0 === this.obj.length
+        , 'expected ' + this.inspect + ' to be empty'
+        , 'expected ' + this.inspect + ' not to be empty');
+
+      return this;
+    },
+    configurable: true
+});
+
+/**
+ * # .arguments
+ *
+ * Assert object is an instanceof arguments.
+ *
+ *      function test () {
+ *        expect(arguments).to.be.arguments;
+ *      }
+ *
+ * @name arguments
+ * @api public
+ */
+
+Object.defineProperty(Assertion.prototype, 'arguments',
+  { get: function () {
+      this.assert(
+          '[object Arguments]' == Object.prototype.toString.call(this.obj)
+        , 'expected ' + this.inspect + ' to be arguments'
+        , 'expected ' + this.inspect + ' to not be arguments');
+
+      return this;
+    },
+    configurable: true
+});
+
+/**
+ * # .equal(value)
+ *
+ * Assert strict equality.
+ *
+ *      expect('hello').to.equal('hello');
+ *
+ * @name equal
+ * @param {*} value
+ * @api public
+ */
+
+Assertion.prototype.equal = function (val) {
+  this.assert(
+      val === this.obj
+    , 'expected ' + this.inspect + ' to equal ' + inspect(val)
+    , 'expected ' + this.inspect + ' to not equal ' + inspect(val));
+
+  return this;
+};
+
+/**
+ * # .eql(value)
+ *
+ * Assert deep equality.
+ *
+ *      expect({ foo: 'bar' }).to.eql({ foo: 'bar' });
+ *
+ * @name eql
+ * @param {*} value
+ * @api public
+ */
+
+Assertion.prototype.eql = function (obj) {
+  this.assert(
+      eql(obj, this.obj)
+    , 'expected ' + this.inspect + ' to equal ' + inspect(obj)
+    , 'expected ' + this.inspect + ' to not equal ' + inspect(obj));
+  return this;
+};
+
+/**
+ * # .above(value)
+ *
+ * Assert greater than `value`.
+ *
+ *      expect(10).to.be.above(5);
+ *
+ * @name above
+ * @param {Number} value
+ * @api public
+ */
+
+Assertion.prototype.above = function (val) {
+  this.assert(
+      this.obj > val
+    , 'expected ' + this.inspect + ' to be above ' + val
+    , 'expected ' + this.inspect + ' to be below ' + val);
+
+  return this;
+};
+
+/**
+ * # .below(value)
+ *
+ * Assert less than `value`.
+ *
+ *      expect(5).to.be.below(10);
+ *
+ * @name below
+ * @param {Number} value
+ * @api public
+ */
+
+Assertion.prototype.below = function (val) {
+  this.assert(
+      this.obj < val
+    , 'expected ' + this.inspect + ' to be below ' + val
+    , 'expected ' + this.inspect + ' to be above ' + val);
+
+  return this;
+};
+
+/**
+ * # .within(start, finish)
+ *
+ * Assert that a number is within a range.
+ *
+ *      expect(7).to.be.within(5,10);
+ *
+ * @name within
+ * @param {Number} start lowerbound inclusive
+ * @param {Number} finish upperbound inclusive
+ * @api public
+ */
+
+Assertion.prototype.within = function (start, finish) {
+  var range = start + '..' + finish;
+
+  this.assert(
+      this.obj >= start && this.obj <= finish
+    , 'expected ' + this.inspect + ' to be within ' + range
+    , 'expected ' + this.inspect + ' to not be within ' + range);
+
+  return this;
+};
+
+/**
+ * # .a(type)
+ *
+ * Assert typeof.
+ *
+ *      expect('test').to.be.a('string');
+ *
+ * @name a
+ * @param {String} type
+ * @api public
+ */
+
+Assertion.prototype.a = function (type) {
+  this.assert(
+      type == typeof this.obj
+    , 'expected ' + this.inspect + ' to be a ' + type
+    , 'expected ' + this.inspect + ' not to be a ' + type);
+
+  return this;
+};
+
+/**
+ * # .instanceof(constructor)
+ *
+ * Assert instanceof.
+ *
+ *      var Tea = function (name) { this.name = name; }
+ *        , Chai = new Tea('chai');
+ *
+ *      expect(Chai).to.be.an.instanceOf(Tea);
+ *
+ * @name instanceof
+ * @param {Constructor}
+ * @alias instanceOf
+ * @api public
+ */
+
+Assertion.prototype.instanceof = function (constructor) {
+  var name = constructor.name;
+  this.assert(
+      this.obj instanceof constructor
+    , 'expected ' + this.inspect + ' to be an instance of ' + name
+    , 'expected ' + this.inspect + ' to not be an instance of ' + name);
+
+  return this;
+};
+
+/**
+ * # .property(name, [value])
+ *
+ * Assert that property of `name` exists, optionally with `value`.
+ *
+ *      var obj = { foo: 'bar' }
+ *      expect(obj).to.have.property('foo');
+ *      expect(obj).to.have.property('foo', 'bar');
+ *      expect(obj).to.have.property('foo').to.be.a('string');
+ *
+ * @name property
+ * @param {String} name
+ * @param {*} value (optional)
+ * @returns value of property for chaining
+ * @api public
+ */
+
+Assertion.prototype.property = function (name, val) {
+  if (this.negate && undefined !== val) {
+    if (undefined === this.obj[name]) {
+      throw new Error(this.inspect + ' has no property ' + inspect(name));
+    }
+  } else {
+    this.assert(
+        undefined !== this.obj[name]
+      , 'expected ' + this.inspect + ' to have a property ' + inspect(name)
+      , 'expected ' + this.inspect + ' to not have property ' + inspect(name));
+  }
+
+  if (undefined !== val) {
+    this.assert(
+        val === this.obj[name]
+      , 'expected ' + this.inspect + ' to have a property ' + inspect(name) + ' of ' +
+          inspect(val) + ', but got ' + inspect(this.obj[name])
+      , 'expected ' + this.inspect + ' to not have a property ' + inspect(name) + ' of ' +  inspect(val));
+  }
+
+  this.obj = this.obj[name];
+  return this;
+};
+
+/**
+ * # .ownProperty(name)
+ *
+ * Assert that has own property by `name`.
+ *
+ *      expect('test').to.have.ownProperty('length');
+ *
+ * @name ownProperty
+ * @alias haveOwnProperty
+ * @param {String} name
+ * @api public
+ */
+
+Assertion.prototype.ownProperty = function (name) {
+  this.assert(
+      this.obj.hasOwnProperty(name)
+    , 'expected ' + this.inspect + ' to have own property ' + inspect(name)
+    , 'expected ' + this.inspect + ' to not have own property ' + inspect(name));
+  return this;
+};
+
+/**
+ * # .length(val)
+ *
+ * Assert that object has expected length.
+ *
+ *      expect([1,2,3]).to.have.length(3);
+ *      expect('foobar').to.have.length(6);
+ *
+ * @name length
+ * @alias lengthOf
+ * @param {Number} length
+ * @api public
+ */
+
+Assertion.prototype.length = function (n) {
+  new Assertion(this.obj).to.have.property('length');
+  var len = this.obj.length;
+
+  this.assert(
+      len == n
+    , 'expected ' + this.inspect + ' to have a length of ' + n + ' but got ' + len
+    , 'expected ' + this.inspect + ' to not have a length of ' + len);
+
+  return this;
+};
+
+/**
+ * # .match(regexp)
+ *
+ * Assert that matches regular expression.
+ *
+ *      expect('foobar').to.match(/^foo/);
+ *
+ * @name match
+ * @param {RegExp} RegularExpression
+ * @api public
+ */
+
+Assertion.prototype.match = function (re) {
+  this.assert(
+      re.exec(this.obj)
+    , 'expected ' + this.inspect + ' to match ' + re
+    , 'expected ' + this.inspect + ' not to match ' + re);
+
+  return this;
+};
+
+/**
+ * # .include(obj)
+ *
+ * Assert the inclusion of an object in an Array or substring in string.
+ *
+ *      expect([1,2,3]).to.contain(2);
+ *
+ * @name include
+ * @param {Object|String|Number} obj
+ * @api public
+ */
+
+Assertion.prototype.include = function (obj) {
+  this.assert(
+      ~this.obj.indexOf(obj)
+    , 'expected ' + this.inspect + ' to include ' + inspect(obj)
+    , 'expected ' + this.inspect + ' to not include ' + inspect(obj));
+
+  return this;
+};
+
+/**
+ * # .string(string)
+ *
+ * Assert inclusion of string in string.
+ *
+ *      expect('foobar').to.include.string('bar');
+ *
+ * @name string
+ * @param {String} string
+ * @api public
+ */
+
+Assertion.prototype.string = function (str) {
+  new Assertion(this.obj).is.a('string');
+
+  this.assert(
+      ~this.obj.indexOf(str)
+    , 'expected ' + this.inspect + ' to contain ' + inspect(str)
+    , 'expected ' + this.inspect + ' to not contain ' + inspect(str));
+
+  return this;
+};
+
+
+
+/**
+ * # contain
+ *
+ * Toggles the `contain` flag for the `keys` assertion.
+ *
+ * @name contain
+ * @api public
+ */
+
+Object.defineProperty(Assertion.prototype, 'contain',
+  { get: function () {
+      this.contains = true;
+      return this;
+    },
+    configurable: true
+});
+
+/**
+ * # .keys(key1, [key2], [...])
+ *
+ * Assert exact keys or the inclusing of keys using the `contain` modifier.
+ *
+ *      expect({ foo: 1, bar: 2 }).to.have.keys(['foo', 'bar']);
+ *      expect({ foo: 1, bar: 2, baz: 3 }).to.contain.keys('foo', 'bar');
+ *
+ * @name keys
+ * @alias key
+ * @param {String|Array} Keys
+ * @api public
+ */
+
+Assertion.prototype.keys = function(keys) {
+  var str
+    , ok = true;
+
+  keys = keys instanceof Array
+    ? keys
+    : Array.prototype.slice.call(arguments);
+
+  if (!keys.length) throw new Error('keys required');
+
+  var actual = Object.keys(this.obj)
+    , len = keys.length;
+
+  // Inclusion
+  ok = keys.every(function(key){
+    return ~actual.indexOf(key);
+  });
+
+  // Strict
+  if (!this.negate && !this.contains) {
+    ok = ok && keys.length == actual.length;
+  }
+
+  // Key string
+  if (len > 1) {
+    keys = keys.map(function(key){
+      return inspect(key);
+    });
+    var last = keys.pop();
+    str = keys.join(', ') + ', and ' + last;
+  } else {
+    str = inspect(keys[0]);
+  }
+
+  // Form
+  str = (len > 1 ? 'keys ' : 'key ') + str;
+
+  // Have / include
+  str = (this.contains ? 'contain ' : 'have ') + str;
+
+  // Assertion
+  this.assert(
+      ok
+    , 'expected ' + this.inspect + ' to ' + str
+    , 'expected ' + this.inspect + ' to not ' + str);
+
+  return this;
+}
+
+/**
+ * # .throw(constructor)
+ *
+ * Assert that a function will throw a specific type of error.
+ *
+ *      var fn = function () { throw new ReferenceError(''); }
+ *      expect(fn).to.throw(ReferenceError);
+ *
+ * @name throw
+ * @alias throws
+ * @alias Throw
+ * @param {ErrorConstructor} constructor
+ * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types
+ * @api public
+ */
+
+Assertion.prototype.throw = function (constructor) {
+  new Assertion(this.obj).is.a('function');
+
+  var thrown = false;
+
+  try {
+    this.obj();
+  } catch (err) {
+    if (constructor && 'function' === typeof constructor && constructor.constructor != RegExp) {
+      this.assert(
+          err instanceof constructor && err.name == constructor.name
+        , 'expected ' + this.inspect + ' to throw ' + constructor.name + ' but a ' + err.name + ' was thrown'
+        , 'expected ' + this.inspect + ' to not throw ' + constructor.name );
+      return this;
+    } else if (constructor && constructor instanceof RegExp) {
+      this.assert(
+          constructor.exec(err.message)
+        , 'expected ' + this.inspect + ' to throw error matching ' + constructor + ' but got ' + inspect(err.message)
+        , 'expected ' + this.inspect + ' to throw error not matching ' + constructor);
+      return this;
+    } else {
+      thrown = true;
+    }
+  }
+
+  var name = (constructor ? constructor.name : 'an error');
+
+  this.assert(
+      thrown === true
+    , 'expected ' + this.inspect + ' to throw ' + name
+    , 'expected ' + this.inspect + ' to not throw ' + name);
+
+  return this;
+};
+
+/*!
+ * Aliases.
+ */
+
+(function alias(name, as){
+  Assertion.prototype[as] = Assertion.prototype[name];
+  return alias;
+})
+('length', 'lengthOf')
+('keys', 'key')
+('ownProperty', 'haveOwnProperty')
+('above', 'greaterThan')
+('below', 'lessThan')
+('throw', 'throws')
+('throw', 'Throw') // for troublesome browsers
+('instanceof', 'instanceOf');
+
+}); // module: assertion.js
+
+require.register("chai.js", function(module, exports, require){
+/*!
+ * chai
+ * Copyright(c) 2011-2012 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+var used = [];
+var exports = module.exports = {};
+
+exports.version = '0.3.3';
+
+exports.Assertion = require('./assertion');
+exports.AssertionError = require('./error');
+
+exports.inspect = require('./utils/inspect');
+
+exports.use = function (fn) {
+  if (!~used.indexOf(fn)) {
+    fn(this);
+    used.push(fn);
+  }
+
+  return this;
+};
+
+exports.fail = function (actual, expected, message, operator, stackStartFunction) {
+  throw new exports.AssertionError({
+    message: message,
+    actual: actual,
+    expected: expected,
+    operator: operator,
+    stackStartFunction: stackStartFunction
+  });
+};
+
+var expect = require('./interface/expect');
+exports.use(expect);
+
+var should = require('./interface/should');
+exports.use(should);
+
+var assert = require('./interface/assert');
+exports.use(assert);
+
+}); // module: chai.js
+
+require.register("error.js", function(module, exports, require){
+/*!
+ * chai
+ * Copyright(c) 2011 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+var fail = require('./chai').fail;
+
+module.exports = AssertionError;
+
+/*!
+ * Inspired by node.js assert module
+ * https://github.com/joyent/node/blob/f8c335d0caf47f16d31413f89aa28eda3878e3aa/lib/assert.js
+ */
+function AssertionError (options) {
+  options = options || {};
+  this.name = 'AssertionError';
+  this.message = options.message;
+  this.actual = options.actual;
+  this.expected = options.expected;
+  this.operator = options.operator;
+  var stackStartFunction = options.stackStartFunction || fail;
+
+  if (Error.captureStackTrace) {
+    Error.captureStackTrace(this, stackStartFunction);
+  }
+}
+
+AssertionError.prototype.__proto__ = Error.prototype;
+
+AssertionError.prototype.summary = function() {
+  var str = '';
+
+  if (this.operator) {
+    str += 'In: \'' + this.operator + '\'\n\t';
+  }
+
+  str += '' + this.name + (this.message ? ': ' + this.message : '');
+
+  return str;
+};
+
+AssertionError.prototype.details = function() {
+  return this.summary();
+};
+
+AssertionError.prototype.toString = function() {
+  return this.summary();
+};
+}); // module: error.js
+
+require.register("interface/assert.js", function(module, exports, require){
+/*!
+ * chai
+ * Copyright(c) 2011 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+/**
+ * ### TDD Style Introduction
+ *
+ * The TDD style is exposed through `assert` interfaces. This provides
+ * the classic assert.`test` notation, similiar to that packaged with
+ * node.js. This assert module, however, provides several additional
+ * tests and is browser compatible.
+ *
+ *      // assert
+ *      var assert = require('chai').assert;
+ *        , foo = 'bar';
+ *
+ *      assert.typeOf(foo, 'string');
+ *      assert.equal(foo, 'bar');
+ */
+
+module.exports = function (chai) {
+  /*!
+   * Chai dependencies.
+   */
+  var Assertion = chai.Assertion
+    , inspect = chai.inspect;
+
+  /*!
+   * Module export.
+   */
+
+  var assert = chai.assert = {};
+
+  /**
+   * # .ok(object, [message])
+   *
+   * Assert object is truthy.
+   *
+   *      assert.ok('everthing', 'everything is ok');
+   *      assert.ok(false, 'this will fail');
+   *
+   * @name ok
+   * @param {*} object to test
+   * @param {String} message
+   * @api public
+   */
+
+  assert.ok = function (val, msg) {
+    new Assertion(val, msg).is.ok;
+  };
+
+  /**
+   * # .equal(actual, expected, [message])
+   *
+   * Assert strict equality.
+   *
+   *      assert.equal(3, 3, 'these numbers are equal');
+   *
+   * @name equal
+   * @param {*} actual
+   * @param {*} expected
+   * @param {String} message
+   * @api public
+   */
+
+  assert.equal = function (act, exp, msg) {
+    var test = new Assertion(act, msg);
+
+    test.assert(
+        exp == test.obj
+      , 'expected ' + test.inspect + ' to equal ' + inspect(exp)
+      , 'expected ' + test.inspect + ' to not equal ' + inspect(exp));
+  };
+
+  /**
+   * # .notEqual(actual, expected, [message])
+   *
+   * Assert not equal.
+   *
+   *      assert.notEqual(3, 4, 'these numbers are not equal');
+   *
+   * @name notEqual
+   * @param {*} actual
+   * @param {*} expected
+   * @param {String} message
+   * @api public
+   */
+
+  assert.notEqual = function (act, exp, msg) {
+    var test = new Assertion(act, msg);
+
+    test.assert(
+        exp != test.obj
+      , 'expected ' + test.inspect + ' to equal ' + inspect(exp)
+      , 'expected ' + test.inspect + ' to not equal ' + inspect(exp));
+  };
+
+  /**
+   * # .strictEqual(actual, expected, [message])
+   *
+   * Assert strict equality.
+   *
+   *      assert.strictEqual(true, true, 'these booleans are strictly equal');
+   *
+   * @name strictEqual
+   * @param {*} actual
+   * @param {*} expected
+   * @param {String} message
+   * @api public
+   */
+
+  assert.strictEqual = function (act, exp, msg) {
+    new Assertion(act, msg).to.equal(exp);
+  };
+
+  /**
+   * # .notStrictEqual(actual, expected, [message])
+   *
+   * Assert strict equality.
+   *
+   *      assert.notStrictEqual(1, true, 'these booleans are not strictly equal');
+   *
+   * @name notStrictEqual
+   * @param {*} actual
+   * @param {*} expected
+   * @param {String} message
+   * @api public
+   */
+
+  assert.notStrictEqual = function (act, exp, msg) {
+    new Assertion(act, msg).to.not.equal(exp);
+  };
+
+  /**
+   * # .deepEqual(actual, expected, [message])
+   *
+   * Assert not deep equality.
+   *
+   *      assert.deepEqual({ tea: 'green' }, { tea: 'green' });
+   *
+   * @name deepEqual
+   * @param {*} actual
+   * @param {*} expected
+   * @param {String} message
+   * @api public
+   */
+
+  assert.deepEqual = function (act, exp, msg) {
+    new Assertion(act, msg).to.eql(exp);
+  };
+
+  /**
+   * # .notDeepEqual(actual, expected, [message])
+   *
+   * Assert not deep equality.
+   *
+   *      assert.notDeepEqual({ tea: 'green' }, { tea: 'jasmine' });
+   *
+   * @name notDeepEqual
+   * @param {*} actual
+   * @param {*} expected
+   * @param {String} message
+   * @api public
+   */
+
+  assert.notDeepEqual = function (act, exp, msg) {
+    new Assertion(act, msg).to.not.eql(exp);
+  };
+
+  /**
+   * # .isTrue(value, [message])
+   *
+   * Assert `value` is true.
+   *
+   *      var tea_served = true;
+   *      assert.isTrue(tea_served, 'the tea has been served');
+   *
+   * @name isTrue
+   * @param {Boolean} value
+   * @param {String} message
+   * @api public
+   */
+
+  assert.isTrue = function (val, msg) {
+    new Assertion(val, msg).is.true;
+  };
+
+  /**
+   * # .isFalse(value, [message])
+   *
+   * Assert `value` is false.
+   *
+   *      var tea_served = false;
+   *      assert.isFalse(tea_served, 'no tea yet? hmm...');
+   *
+   * @name isFalse
+   * @param {Boolean} value
+   * @param {String} message
+   * @api public
+   */
+
+  assert.isFalse = function (val, msg) {
+    new Assertion(val, msg).is.false;
+  };
+
+  /**
+   * # .isNull(value, [message])
+   *
+   * Assert `value` is null.
+   *
+   *      assert.isNull(err, 'no errors');
+   *
+   * @name isNull
+   * @param {*} value
+   * @param {String} message
+   * @api public
+   */
+
+  assert.isNull = function (val, msg) {
+    new Assertion(val, msg).to.not.exist;
+  };
+
+  /**
+   * # .isNotNull(value, [message])
+   *
+   * Assert `value` is not null.
+   *
+   *      var tea = 'tasty chai';
+   *      assert.isNotNull(tea, 'great, time for tea!');
+   *
+   * @name isNotNull
+   * @param {*} value
+   * @param {String} message
+   * @api public
+   */
+
+  assert.isNotNull = function (val, msg) {
+    new Assertion(val, msg).to.exist;
+  };
+
+  /**
+   * # .isUndefined(value, [message])
+   *
+   * Assert `value` is undefined.
+   *
+   *      assert.isUndefined(tea, 'no tea defined');
+   *
+   * @name isUndefined
+   * @param {*} value
+   * @param {String} message
+   * @api public
+   */
+
+  assert.isUndefined = function (val, msg) {
+    new Assertion(val, msg).to.equal(undefined);
+  };
+
+  /**
+   * # .isFunction(value, [message])
+   *
+   * Assert `value` is a function.
+   *
+   *      var serve_tea = function () { return 'cup of tea'; };
+   *      assert.isFunction(serve_tea, 'great, we can have tea now');
+   *
+   * @name isFunction
+   * @param {Function} value
+   * @param {String} message
+   * @api public
+   */
+
+  assert.isFunction = function (val, msg) {
+    new Assertion(val, msg).to.be.a('function');
+  };
+
+  /**
+   * # .isObject(value, [message])
+   *
+   * Assert `value` is an object.
+   *
+   *      var selection = { name: 'Chai', serve: 'with spices' };
+   *      assert.isObject(selection, 'tea selection is an object');
+   *
+   * @name isObject
+   * @param {Object} value
+   * @param {String} message
+   * @api public
+   */
+
+  assert.isObject = function (val, msg) {
+    new Assertion(val, msg).to.be.a('object');
+  };
+
+  /**
+   * # .isArray(value, [message])
+   *
+   * Assert `value` is an instance of Array.
+   *
+   *      var menu = [ 'green', 'chai', 'oolong' ];
+   *      assert.isArray(menu, 'what kind of tea do we want?');
+   *
+   * @name isArray
+   * @param {*} value
+   * @param {String} message
+   * @api public
+   */
+
+  assert.isArray = function (val, msg) {
+    new Assertion(val, msg).to.be.instanceof(Array);
+  };
+
+  /**
+   * # .isString(value, [message])
+   *
+   * Assert `value` is a string.
+   *
+   *      var teaorder = 'chai';
+   *      assert.isString(tea_order, 'order placed');
+   *
+   * @name isString
+   * @param {String} value
+   * @param {String} message
+   * @api public
+   */
+
+  assert.isString = function (val, msg) {
+    new Assertion(val, msg).to.be.a('string');
+  };
+
+  /**
+   * # .isNumber(value, [message])
+   *
+   * Assert `value` is a number
+   *
+   *      var cups = 2;
+   *      assert.isNumber(cups, 'how many cups');
+   *
+   * @name isNumber
+   * @param {Number} value
+   * @param {String} message
+   * @api public
+   */
+
+  assert.isNumber = function (val, msg) {
+    new Assertion(val, msg).to.be.instanceof(Number);
+  };
+
+  /**
+   * # .isBoolean(value, [message])
+   *
+   * Assert `value` is a boolean
+   *
+   *      var teaready = true
+   *        , teaserved = false;
+   *
+   *      assert.isBoolean(tea_ready, 'is the tea ready');
+   *      assert.isBoolean(tea_served, 'has tea been served');
+   *
+   * @name isBoolean
+   * @param {*} value
+   * @param {String} message
+   * @api public
+   */
+
+  assert.isBoolean = function (val, msg) {
+    new Assertion(val, msg).to.be.a('boolean');
+  };
+
+  /**
+   * # .typeOf(value, name, [message])
+   *
+   * Assert typeof `value` is `name`.
+   *
+   *      assert.typeOf('tea', 'string', 'we have a string');
+   *
+   * @name typeOf
+   * @param {*} value
+   * @param {String} typeof name
+   * @param {String} message
+   * @api public
+   */
+
+  assert.typeOf = function (val, type, msg) {
+    new Assertion(val, msg).to.be.a(type);
+  };
+
+  /**
+   * # .instanceOf(object, constructor, [message])
+   *
+   * Assert `value` is instanceof `constructor`.
+   *
+   *      var Tea = function (name) { this.name = name; }
+   *        , Chai = new Tea('chai');
+   *
+   *      assert.instanceOf(Chai, Tea, 'chai is an instance of tea');
+   *
+   * @name instanceOf
+   * @param {Object} object
+   * @param {Constructor} constructor
+   * @param {String} message
+   * @api public
+   */
+
+  assert.instanceOf = function (val, type, msg) {
+    new Assertion(val, msg).to.be.instanceof(type);
+  };
+
+  /**
+   * # .include(value, includes, [message])
+   *
+   * Assert the inclusion of an object in another. Works
+   * for strings and arrays.
+   *
+   *      assert.include('foobar', 'bar', 'foobar contains string `var`);
+   *      assert.include([ 1, 2, 3], 3, 'array contains value);
+   *
+   * @name include
+   * @param {Array|String} value
+   * @param {*} includes
+   * @param {String} message
+   * @api public
+   */
+
+  assert.include = function (exp, inc, msg) {
+    var obj = new Assertion(exp, msg);
+
+    if (Array.isArray(exp)) {
+      obj.to.include(inc);
+    } else if ('string' === typeof exp) {
+      obj.to.contain.string(inc);
+    }
+  };
+
+  /**
+   * # .match(value, regex, [message])
+   *
+   * Assert that `value` matches regular expression.
+   *
+   *      assert.match('foobar', /^foo/, 'Regexp matches');
+   *
+   * @name match
+   * @param {*} value
+   * @param {RegExp} RegularExpression
+   * @param {String} message
+   * @api public
+   */
+
+  assert.match = function (exp, re, msg) {
+    new Assertion(exp, msg).to.match(re);
+  };
+
+  /**
+   * # .length(value, constructor, [message])
+   *
+   * Assert that object has expected length.
+   *
+   *      assert.length([1,2,3], 3, 'Array has length of 3');
+   *      assert.length('foobar', 5, 'String has length of 6');
+   *
+   * @name length
+   * @param {*} value
+   * @param {Number} length
+   * @param {String} message
+   * @api public
+   */
+
+  assert.length = function (exp, len, msg) {
+    new Assertion(exp, msg).to.have.length(len);
+  };
+
+  /**
+   * # .throws(function, [constructor/regexp], [message])
+   *
+   * Assert that a function will throw a specific
+   * type of error.
+   *
+   *      assert.throw(fn, ReferenceError, 'function throw reference error');
+   *
+   * @name throws
+   * @alias throw
+   * @param {Function} function to test
+   * @param {ErrorConstructor} constructor
+   * @param {String} message
+   * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types
+   * @api public
+   */
+
+  assert.throws = function (fn, type, msg) {
+    if ('string' === typeof type) {
+      msg = type;
+      type = null;
+    }
+
+    new Assertion(fn, msg).to.throw(type);
+  };
+
+  /**
+   * # .doesNotThrow(function, [constructor/regexp], [message])
+   *
+   * Assert that a function will throw a specific
+   * type of error.
+   *
+   *      var fn = function (err) { if (err) throw Error(err) };
+   *      assert.doesNotThrow(fn, Error, 'function throw reference error');
+   *
+   * @name doesNotThrow
+   * @param {Function} function to test
+   * @param {ErrorConstructor} constructor
+   * @param {String} message
+   * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types
+   * @api public
+   */
+
+  assert.doesNotThrow = function (fn, type, msg) {
+    if ('string' === typeof type) {
+      msg = type;
+      type = null;
+    }
+
+    new Assertion(fn, msg).to.not.throw(type);
+  };
+
+  /*!
+   * Undocumented / untested
+   */
+
+  assert.ifError = function (val, msg) {
+    new Assertion(val, msg).to.not.be.ok;
+  };
+
+  /*!
+   * Aliases.
+   */
+
+  (function alias(name, as){
+    assert[as] = assert[name];
+    return alias;
+  })
+  ('length', 'lengthOf')
+  ('throws', 'throw');
+};
+
+}); // module: interface/assert.js
+
+require.register("interface/expect.js", function(module, exports, require){
+/*!
+ * chai
+ * Copyright(c) 2011 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+module.exports = function (chai) {
+  chai.expect = function (val, message) {
+    return new chai.Assertion(val, message);
+  };
+};
+
+
+}); // module: interface/expect.js
+
+require.register("interface/should.js", function(module, exports, require){
+/*!
+ * chai
+ * Copyright(c) 2011 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+module.exports = function (chai) {
+  var Assertion = chai.Assertion;
+
+  chai.should = function () {
+    // modify Object.prototype to have `should`
+    Object.defineProperty(Object.prototype, 'should', {
+      set: function(){},
+      get: function(){
+        if (this instanceof String || this instanceof Number) {
+          return new Assertion(this.constructor(this));
+        } else if (this instanceof Boolean) {
+          return new Assertion(this == true);
+        }
+        return new Assertion(this);
+      },
+      configurable: true
+    });
+
+    var should = {};
+
+    should.equal = function (val1, val2) {
+      new Assertion(val1).to.equal(val2);
+    };
+
+    should.throw = function (fn, err) {
+      new Assertion(fn).to.throw(err);
+    };
+
+    should.exist = function (val) {
+      new Assertion(val).to.exist;
+    }
+
+    // negation
+    should.not = {}
+
+    should.not.equal = function (val1, val2) {
+      new Assertion(val1).to.not.equal(val2);
+    };
+
+    should.not.throw = function (fn, err) {
+      new Assertion(fn).to.not.throw(err);
+    };
+
+    should.not.exist = function (val) {
+      new Assertion(val).to.not.exist;
+    }
+
+    return should;
+  };
+};
+
+}); // module: interface/should.js
+
+require.register("utils/eql.js", function(module, exports, require){
+// This is directly from Node.js assert
+// https://github.com/joyent/node/blob/f8c335d0caf47f16d31413f89aa28eda3878e3aa/lib/assert.js
+
+
+module.exports = _deepEqual;
+
+// For browser implementation
+if (!Buffer) {
+  var Buffer = {
+    isBuffer: function () {
+      return false;
+    }
+  };
+}
+
+function _deepEqual(actual, expected) {
+  // 7.1. All identical values are equivalent, as determined by ===.
+  if (actual === expected) {
+    return true;
+
+  } else if (Buffer.isBuffer(actual) && Buffer.isBuffer(expected)) {
+    if (actual.length != expected.length) return false;
+
+    for (var i = 0; i < actual.length; i++) {
+      if (actual[i] !== expected[i]) return false;
+    }
+
+    return true;
+
+  // 7.2. If the expected value is a Date object, the actual value is
+  // equivalent if it is also a Date object that refers to the same time.
+  } else if (actual instanceof Date && expected instanceof Date) {
+    return actual.getTime() === expected.getTime();
+
+  // 7.3. Other pairs that do not both pass typeof value == 'object',
+  // equivalence is determined by ==.
+  } else if (typeof actual != 'object' && typeof expected != 'object') {
+    return actual === expected;
+
+  // 7.4. For all other Object pairs, including Array objects, equivalence is
+  // determined by having the same number of owned properties (as verified
+  // with Object.prototype.hasOwnProperty.call), the same set of keys
+  // (although not necessarily the same order), equivalent values for every
+  // corresponding key, and an identical 'prototype' property. Note: this
+  // accounts for both named and indexed properties on Arrays.
+  } else {
+    return objEquiv(actual, expected);
+  }
+}
+
+function isUndefinedOrNull(value) {
+  return value === null || value === undefined;
+}
+
+function isArguments(object) {
+  return Object.prototype.toString.call(object) == '[object Arguments]';
+}
+
+function objEquiv(a, b) {
+  if (isUndefinedOrNull(a) || isUndefinedOrNull(b))
+    return false;
+  // an identical 'prototype' property.
+  if (a.prototype !== b.prototype) return false;
+  //~~~I've managed to break Object.keys through screwy arguments passing.
+  //   Converting to array solves the problem.
+  if (isArguments(a)) {
+    if (!isArguments(b)) {
+      return false;
+    }
+    a = pSlice.call(a);
+    b = pSlice.call(b);
+    return _deepEqual(a, b);
+  }
+  try {
+    var ka = Object.keys(a),
+        kb = Object.keys(b),
+        key, i;
+  } catch (e) {//happens when one is a string literal and the other isn't
+    return false;
+  }
+  // having the same number of owned properties (keys incorporates
+  // hasOwnProperty)
+  if (ka.length != kb.length)
+    return false;
+  //the same set of keys (although not necessarily the same order),
+  ka.sort();
+  kb.sort();
+  //~~~cheap key test
+  for (i = ka.length - 1; i >= 0; i--) {
+    if (ka[i] != kb[i])
+      return false;
+  }
+  //equivalent values for every corresponding key, and
+  //~~~possibly expensive deep test
+  for (i = ka.length - 1; i >= 0; i--) {
+    key = ka[i];
+    if (!_deepEqual(a[key], b[key])) return false;
+  }
+  return true;
+}
+}); // module: utils/eql.js
+
+require.register("utils/inspect.js", function(module, exports, require){
+// This is (almost) directly from Node.js utils
+// https://github.com/joyent/node/blob/f8c335d0caf47f16d31413f89aa28eda3878e3aa/lib/util.js
+
+module.exports = inspect;
+
+/**
+ * Echos the value of a value. Trys to print the value out
+ * in the best way possible given the different types.
+ *
+ * @param {Object} obj The object to print out.
+ * @param {Boolean} showHidden Flag that shows hidden (not enumerable)
+ *    properties of objects.
+ * @param {Number} depth Depth in which to descend in object. Default is 2.
+ * @param {Boolean} colors Flag to turn on ANSI escape codes to color the
+ *    output. Default is false (no coloring).
+ */
+function inspect(obj, showHidden, depth, colors) {
+  var ctx = {
+    showHidden: showHidden,
+    seen: [],
+    stylize: function (str) { return str; }
+  };
+  return formatValue(ctx, obj, (typeof depth === 'undefined' ? 2 : depth));
+}
+
+function formatValue(ctx, value, recurseTimes) {
+  // Provide a hook for user-specified inspect functions.
+  // Check that value is an object with an inspect function on it
+  if (value && typeof value.inspect === 'function' &&
+      // Filter out the util module, it's inspect function is special
+      value.inspect !== exports.inspect &&
+      // Also filter out any prototype objects using the circular check.
+      !(value.constructor && value.constructor.prototype === value)) {
+    return value.inspect(recurseTimes);
+  }
+
+  // Primitive types cannot have properties
+  var primitive = formatPrimitive(ctx, value);
+  if (primitive) {
+    return primitive;
+  }
+
+  // Look up the keys of the object.
+  var visibleKeys = Object.keys(value);
+  var keys = ctx.showHidden ? Object.getOwnPropertyNames(value) : visibleKeys;
+
+  // Some type of object without properties can be shortcutted.
+  if (keys.length === 0) {
+    if (typeof value === 'function') {
+      var name = value.name ? ': ' + value.name : '';
+      return ctx.stylize('[Function' + name + ']', 'special');
+    }
+    if (isRegExp(value)) {
+      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+    }
+    if (isDate(value)) {
+      return ctx.stylize(Date.prototype.toUTCString.call(value), 'date');
+    }
+    if (isError(value)) {
+      return formatError(value);
+    }
+  }
+
+  var base = '', array = false, braces = ['{', '}'];
+
+  // Make Array say that they are Array
+  if (isArray(value)) {
+    array = true;
+    braces = ['[', ']'];
+  }
+
+  // Make functions say that they are functions
+  if (typeof value === 'function') {
+    var n = value.name ? ': ' + value.name : '';
+    base = ' [Function' + n + ']';
+  }
+
+  // Make RegExps say that they are RegExps
+  if (isRegExp(value)) {
+    base = ' ' + RegExp.prototype.toString.call(value);
+  }
+
+  // Make dates with properties first say the date
+  if (isDate(value)) {
+    base = ' ' + Date.prototype.toUTCString.call(value);
+  }
+
+  // Make error with message first say the error
+  if (isError(value)) {
+    base = ' ' + formatError(value);
+  }
+
+  if (keys.length === 0 && (!array || value.length == 0)) {
+    return braces[0] + base + braces[1];
+  }
+
+  if (recurseTimes < 0) {
+    if (isRegExp(value)) {
+      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+    } else {
+      return ctx.stylize('[Object]', 'special');
+    }
+  }
+
+  ctx.seen.push(value);
+
+  var output;
+  if (array) {
+    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
+  } else {
+    output = keys.map(function(key) {
+      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
+    });
+  }
+
+  ctx.seen.pop();
+
+  return reduceToSingleString(output, base, braces);
+}
+
+
+function formatPrimitive(ctx, value) {
+  switch (typeof value) {
+    case 'undefined':
+      return ctx.stylize('undefined', 'undefined');
+
+    case 'string':
+      var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
+                                               .replace(/'/g, "\\'")
+                                               .replace(/\\"/g, '"') + '\'';
+      return ctx.stylize(simple, 'string');
+
+    case 'number':
+      return ctx.stylize('' + value, 'number');
+
+    case 'boolean':
+      return ctx.stylize('' + value, 'boolean');
+  }
+  // For some reason typeof null is "object", so special case here.
+  if (value === null) {
+    return ctx.stylize('null', 'null');
+  }
+}
+
+
+function formatError(value) {
+  return '[' + Error.prototype.toString.call(value) + ']';
+}
+
+
+function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
+  var output = [];
+  for (var i = 0, l = value.length; i < l; ++i) {
+    if (Object.prototype.hasOwnProperty.call(value, String(i))) {
+      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
+          String(i), true));
+    } else {
+      output.push('');
+    }
+  }
+  keys.forEach(function(key) {
+    if (!key.match(/^\d+$/)) {
+      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
+          key, true));
+    }
+  });
+  return output;
+}
+
+
+function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
+  var name, str;
+  if (value.__lookupGetter__) {
+    if (value.__lookupGetter__(key)) {
+      if (value.__lookupSetter__(key)) {
+        str = ctx.stylize('[Getter/Setter]', 'special');
+      } else {
+        str = ctx.stylize('[Getter]', 'special');
+      }
+    } else {
+      if (value.__lookupSetter__(key)) {
+        str = ctx.stylize('[Setter]', 'special');
+      }
+    }
+  }
+  if (visibleKeys.indexOf(key) < 0) {
+    name = '[' + key + ']';
+  }
+  if (!str) {
+    if (ctx.seen.indexOf(value[key]) < 0) {
+      if (recurseTimes === null) {
+        str = formatValue(ctx, value[key], null);
+      } else {
+        str = formatValue(ctx, value[key], recurseTimes - 1);
+      }
+      if (str.indexOf('\n') > -1) {
+        if (array) {
+          str = str.split('\n').map(function(line) {
+            return '  ' + line;
+          }).join('\n').substr(2);
+        } else {
+          str = '\n' + str.split('\n').map(function(line) {
+            return '   ' + line;
+          }).join('\n');
+        }
+      }
+    } else {
+      str = ctx.stylize('[Circular]', 'special');
+    }
+  }
+  if (typeof name === 'undefined') {
+    if (array && key.match(/^\d+$/)) {
+      return str;
+    }
+    name = JSON.stringify('' + key);
+    if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
+      name = name.substr(1, name.length - 2);
+      name = ctx.stylize(name, 'name');
+    } else {
+      name = name.replace(/'/g, "\\'")
+                 .replace(/\\"/g, '"')
+                 .replace(/(^"|"$)/g, "'");
+      name = ctx.stylize(name, 'string');
+    }
+  }
+
+  return name + ': ' + str;
+}
+
+
+function reduceToSingleString(output, base, braces) {
+  var numLinesEst = 0;
+  var length = output.reduce(function(prev, cur) {
+    numLinesEst++;
+    if (cur.indexOf('\n') >= 0) numLinesEst++;
+    return prev + cur.length + 1;
+  }, 0);
+
+  if (length > 60) {
+    return braces[0] +
+           (base === '' ? '' : base + '\n ') +
+           ' ' +
+           output.join(',\n  ') +
+           ' ' +
+           braces[1];
+  }
+
+  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
+}
+
+function isArray(ar) {
+  return Array.isArray(ar) ||
+         (typeof ar === 'object' && objectToString(ar) === '[object Array]');
+}
+
+function isRegExp(re) {
+  return typeof re === 'object' && objectToString(re) === '[object RegExp]';
+}
+
+function isDate(d) {
+  return typeof d === 'object' && objectToString(d) === '[object Date]';
+}
+
+function isError(e) {
+  return typeof e === 'object' && objectToString(e) === '[object Error]';
+}
+
+function objectToString(o) {
+  return Object.prototype.toString.call(o);
+}
+}); // module: utils/inspect.js
+
+
+  return require('chai');
+});