RubyGems - konacha - Versions diffs - 3.0.0 → 3.1.0 - Mend

konacha 3.0.0 → 3.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (20) hide show

checksums.yaml +7 -0
data/.gitignore +1 -0
data/.travis.yml +1 -4
data/Gemfile +3 -0
data/Gemfile-rails3 +5 -0
data/History.md +6 -0
data/README.md +14 -7
data/app/assets/stylesheets/konacha.css +10 -1
data/konacha.gemspec +2 -2
data/lib/konacha/reporter/example.rb +7 -0
data/lib/konacha/reporter/example_group.rb +8 -0
data/spec/dummy/config/application.rb +0 -1
data/spec/reporter/example_group_spec.rb +24 -2
data/spec/reporter/example_spec.rb +24 -2
data/spec/runner_spec.rb +1 -1
data/vendor/assets/javascripts/chai.js +831 -386
data/vendor/assets/javascripts/mocha.js +786 -347
data/vendor/assets/stylesheets/mocha.css +31 -11
metadata +48 -81
data/Gemfile-rails4 +0 -7

checksums.yaml ADDED Viewed

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9706057c4d4f50ab91f189c6a9c116e0990795c6
+  data.tar.gz: 34ca0d65cb02b227dbb22dcce18ec0e9e91d1927
+SHA512:
+  metadata.gz: 28e650c18b0f41f2ccd199c3b8b1eca3c62ecebf06e117d06ca0aa0ee3242d7e8dc9a94d4898504c82129f95f5ba1e822626b7fb373e34ce51c41c8fde1d7e2d
+  data.tar.gz: b0f2fd3fbb0a117345ee85804e970a1bbaf047718c5a73354b616fd098d899829e8e6e58fccb9b66f0ef97105f69a1ab4b8f1e493acd1b12b734acb9ea742499

data/.gitignore CHANGED Viewed

@@ -5,6 +5,7 @@ bin
 .config
 .yardoc
 Gemfile.lock
+Gemfile-rails3.lock
 InstalledFiles
 _yardoc
 coverage

data/.travis.yml CHANGED Viewed

@@ -4,10 +4,7 @@ rvm:
   - 2.0.0
 gemfile:
   - Gemfile
-  - Gemfile-rails4
+  - Gemfile-rails3
 before_script:
   - sh -e /etc/init.d/xvfb start
   - export DISPLAY=:99.0
-matrix:
-  allow_failures:
-    - { gemfile: Gemfile-rails4 }

data/Gemfile CHANGED Viewed

@@ -1,2 +1,5 @@
 source 'https://rubygems.org'
 gemspec
+gem "sprockets-rails"
+gem "activemodel" # https://github.com/rspec/rspec-rails/pull/798

data/Gemfile-rails3 ADDED Viewed

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+gemspec
+gem "railties", "~> 3.2"
+gem "actionpack", "~> 3.2"

data/History.md CHANGED Viewed

@@ -1,5 +1,11 @@
 # master
+# 3.1.0
+* Update mocha (1.17.1) and chai (1.9.0)
+* Compatibility with yarjuf RSpec formatter (#164)
+* Improve runner styling (#152)
 # 3.0.0
 * Update mocha (1.10.0)

data/README.md CHANGED Viewed

@@ -182,8 +182,8 @@ Konacha can be configured in an initializer, e.g. `config/initializers/konacha.r
 Konacha.configure do |config|
   config.spec_dir     = "spec/javascripts"
   config.spec_matcher = /_spec\.|_test\./
-  config.driver       = :selenium
   config.stylesheets  = %w(application)
+  config.driver       = :selenium
 end if defined?(Konacha)
 ```
@@ -192,13 +192,20 @@ environment.
 The `spec_dir` option tells Konacha where to find JavaScript specs.  `spec_matcher`
 is an object responding to `===` (most likely a `Regexp`); it receives a filename
-and should return true if the file is a spec. `driver` names a Capybara driver used
-for the `run` task (try `:poltergeist`, after installing
-[PhantomJS](https://github.com/jonleighton/poltergeist#installing-phantomjs)).
-The `stylesheets` option sets the stylesheets to be linked from the `<head>`
-of the test runner iframe.
+and should return true if the file is a spec. The `stylesheets` option sets the
+stylesheets to be linked from the `<head>` of the test runner iframe. `driver`
+names a Capybara driver used for the `run` task. The values above are the defaults.
-The values above are the defaults.
+For [PhantomJS](https://github.com/jonleighton/poltergeist#installing-phantomjs)
+support you can use the [poltergeist](https://github.com/jonleighton/poltergeist)
+driver. Require capybara/poltergeist in the configure block:
+```ruby
+Konacha.configure do |config|
+  require 'capybara/poltergeist'
+  config.driver = :poltergeist
+end if defined?(Konacha)
+```
 ## Test Interface and Assertions

data/app/assets/stylesheets/konacha.css CHANGED Viewed

@@ -13,7 +13,7 @@ body {
        -o-transform-origin: right top;
           transform-origin: right top;
-  width: 1000px;
+  width: 55%;
   height: 700px;
   position: fixed;
@@ -34,8 +34,14 @@ body {
   display: none;
 }
+#mocha {
+  width: 40%;
+}
 @media (max-width: 1860px) {
   .test-context {
+    width: 66%;
     -webkit-transform: scale(0.6666666666);
        -moz-transform: scale(0.6666666666);
         -ms-transform: scale(0.6666666666);
@@ -46,6 +52,7 @@ body {
 @media (max-width: 1550px) {
   .test-context {
+    width: 100%;
     -webkit-transform: scale(0.5);
        -moz-transform: scale(0.5);
         -ms-transform: scale(0.5);
@@ -56,6 +63,7 @@ body {
 @media (max-width: 1230px) {
   .test-context {
+    width: 150%;
     -webkit-transform: scale(0.3333333333);
        -moz-transform: scale(0.3333333333);
         -ms-transform: scale(0.3333333333);
@@ -66,6 +74,7 @@ body {
 @media (max-width: 1050px) {
   .test-context {
+    width: 250%;
     -webkit-transform: scale(0.2);
        -moz-transform: scale(0.2);
         -ms-transform: scale(0.2);

data/konacha.gemspec CHANGED Viewed

@@ -17,7 +17,7 @@ the asset pipeline and engines.}
   gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   gem.name          = "konacha"
   gem.require_paths = ["lib"]
-  gem.version       = "3.0.0"
+  gem.version       = "3.1.0"
   gem.license       = "MIT"
   gem.add_dependency "railties", ">= 3.1", "< 5"
@@ -27,7 +27,7 @@ the asset pipeline and engines.}
   gem.add_dependency "colorize"
   gem.add_development_dependency "jquery-rails"
-  gem.add_development_dependency "rspec-rails", "~> 2.12"
+  gem.add_development_dependency "rspec-rails", "~> 2.14"
   gem.add_development_dependency "capybara-firebug", "~> 1.1"
   gem.add_development_dependency "coffee-script"
   gem.add_development_dependency "ejs"

data/lib/konacha/reporter/example.rb CHANGED Viewed

@@ -10,6 +10,9 @@ module Konacha
       def initialize(data, parent)
         @metadata = Metadata.new(data)
         @parent = parent
+        if parent
+          update_metadata(example_group: parent.metadata)
+        end
       end
       delegate :full_description, :description, :location, :file_path, :line_number, :pending, :pending_message, :exception, :execution_result, :to => :metadata
@@ -29,6 +32,10 @@ module Konacha
       def update_metadata(data)
         metadata.update(data)
       end
+      def [](key)
+        respond_to?(key) ? send(key) : metadata[key]
+      end
     end
   end
 end

data/lib/konacha/reporter/example_group.rb CHANGED Viewed

@@ -10,11 +10,15 @@ module Konacha
       def initialize(data, parent)
         @metadata = Metadata.new(data)
         @parent = parent
+        if parent
+          update_metadata(example_group: parent.metadata)
+        end
       end
       delegate :full_description, :description, :file_path, :described_class, :to => :metadata
       alias_method :display_name, :description
+      alias_method :example_group, :parent
       def parent_groups
         ancestor = parent
@@ -32,6 +36,10 @@ module Konacha
       def update_metadata(data)
         metadata.update(data)
       end
+      def [](key)
+        respond_to?(key) ? send(key) : metadata[key]
+      end
     end
   end
 end

data/spec/dummy/config/application.rb CHANGED Viewed

@@ -2,7 +2,6 @@ require File.expand_path('../boot', __FILE__)
 require "action_controller/railtie"
 require "action_view/railtie"
-require "active_model/railtie" # https://github.com/rspec/rspec-rails/pull/642
 require "sprockets/railtie"
 if defined?(Bundler)

data/spec/reporter/example_group_spec.rb CHANGED Viewed

@@ -6,9 +6,14 @@ describe Konacha::Reporter::ExampleGroup do
   describe "#initialize" do
     it "loads up a metadata instance and the parent" do
       data = double('data')
-      parent = double('parent')
-      example_group = described_class.new(data, parent)
+      parent_metadata = Konacha::Reporter::Metadata.new({})
+      parent = double('parent', metadata: parent_metadata)
+      # Check if parent metadata is added to metadata
+      described_class.any_instance.stub(:update_metadata) { nil }
+      described_class.any_instance.should_receive(:update_metadata).with(example_group: parent_metadata)
+      example_group = described_class.new(data, parent)
       example_group.parent.should == parent
       example_group.metadata.should be_a(Konacha::Reporter::Metadata)
       example_group.metadata.data.should == data
@@ -61,4 +66,21 @@ describe Konacha::Reporter::ExampleGroup do
       subject.update_metadata(data)
     end
   end
+  describe "#[]" do
+    it "should delegate to instance method if it exists" do
+      subject.stub(:some_method) { nil }
+      subject.stub(:metadata) { nil }
+      subject.should_receive(:some_method)
+      subject.should_not_receive(:metadata)
+      subject[:some_method]
+    end
+    it "should delegate to metadata if no method exists" do
+      subject.should_not respond_to(:some_method)
+      subject.metadata.stub(:[]) { nil }
+      subject.metadata.should_receive(:[]).with(:some_method)
+      subject[:some_method]
+    end
+  end
 end

data/spec/reporter/example_spec.rb CHANGED Viewed

@@ -6,9 +6,14 @@ describe Konacha::Reporter::Example do
   describe "#initialize" do
     it "loads up a metadata instance and the parent" do
       data = double('data')
-      parent = double('parent')
-      example = described_class.new(data, parent)
+      parent_metadata = Konacha::Reporter::Metadata.new({})
+      parent = double('parent', metadata: parent_metadata)
+      # Check if parent metadata is added to metadata
+      described_class.any_instance.stub(:update_metadata) { nil }
+      described_class.any_instance.should_receive(:update_metadata).with(example_group: parent_metadata)
+      example = described_class.new(data, parent)
       example.parent.should == parent
       example.metadata.should be_a(Konacha::Reporter::Metadata)
       example.metadata.data.should == data
@@ -74,4 +79,21 @@ describe Konacha::Reporter::Example do
       subject.update_metadata(data)
     end
   end
+  describe "#[]" do
+    it "should delegate to instance method if it exists" do
+      subject.stub(:some_method) { nil }
+      subject.stub(:metadata) { nil }
+      subject.should_receive(:some_method)
+      subject.should_not_receive(:metadata)
+      subject[:some_method]
+    end
+    it "should delegate to metadata if no method exists" do
+      subject.should_not respond_to(:some_method)
+      subject.metadata.stub(:[]) { nil }
+      subject.metadata.should_receive(:[]).with(:some_method)
+      subject[:some_method]
+    end
+  end
 end

data/spec/runner_spec.rb CHANGED Viewed

@@ -140,7 +140,7 @@ describe Konacha::Runner do
         subject.reporter.should_receive(:process_mocha_event).with(pass)
         subject.reporter.should_receive(:process_mocha_event).with(pending)
         subject.reporter.should_receive(:process_mocha_event).with(end_event)
-        subject.reporter.should_receive(:process_mocha_event).any_number_of_times
+        subject.reporter.stub(:process_mocha_event)
         subject.run
       end

data/vendor/assets/javascripts/chai.js CHANGED Viewed

@@ -27,10 +27,14 @@ function require(path, parent, orig) {
   // perform real require()
   // by invoking the module's
   // registered function
-  if (!module.exports) {
-    module.exports = {};
-    module.client = module.component = true;
-    module.call(this, module.exports, require.relative(resolved), module);
+  if (!module._resolving && !module.exports) {
+    var mod = {};
+    mod.exports = {};
+    mod.client = mod.component = true;
+    module._resolving = true;
+    module.call(this, mod.exports, require.relative(resolved), mod);
+    delete module._resolving;
+    module.exports = mod.exports;
   }
   return module.exports;
@@ -64,7 +68,6 @@ require.aliases = {};
 require.resolve = function(path) {
   if (path.charAt(0) === '/') path = path.slice(1);
-  var index = path + '/index.js';
   var paths = [
     path,
@@ -77,10 +80,7 @@ require.resolve = function(path) {
   for (var i = 0; i < paths.length; i++) {
     var path = paths[i];
     if (require.modules.hasOwnProperty(path)) return path;
-  }
-  if (require.aliases.hasOwnProperty(index)) {
-    return require.aliases[index];
+    if (require.aliases.hasOwnProperty(path)) return require.aliases[path];
   }
 };
@@ -200,287 +200,745 @@ require.relative = function(parent) {
   return localRequire;
 };
-require.register("chai/index.js", function(exports, require, module){
-module.exports = require('./lib/chai');
-});
-require.register("chai/lib/chai.js", function(exports, require, module){
+require.register("chaijs-assertion-error/index.js", function(exports, require, module){
 /*!
- * chai
- * Copyright(c) 2011-2013 Jake Luer <jake@alogicalparadox.com>
+ * assertion-error
+ * Copyright(c) 2013 Jake Luer <jake@qualiancy.com>
  * MIT Licensed
  */
-var used = []
-  , exports = module.exports = {};
+/*!
+ * Return a function that will copy properties from
+ * one object to another excluding any originally
+ * listed. Returned function will create a new `{}`.
+ *
+ * @param {String} excluded properties ...
+ * @return {Function}
+ */
+function exclude () {
+  var excludes = [].slice.call(arguments);
+  function excludeProps (res, obj) {
+    Object.keys(obj).forEach(function (key) {
+      if (!~excludes.indexOf(key)) res[key] = obj[key];
+    });
+  }
+  return function extendExclude () {
+    var args = [].slice.call(arguments)
+      , i = 0
+      , res = {};
+    for (; i < args.length; i++) {
+      excludeProps(res, args[i]);
+    }
+    return res;
+  };
+};
 /*!
- * Chai version
+ * Primary Exports
+ */
+module.exports = AssertionError;
+/**
+ * ### AssertionError
+ *
+ * An extension of the JavaScript `Error` constructor for
+ * assertion and validation scenarios.
+ *
+ * @param {String} message
+ * @param {Object} properties to include (optional)
+ * @param {callee} start stack function (optional)
  */
-exports.version = '1.6.0';
+function AssertionError (message, _props, ssf) {
+  var extend = exclude('name', 'message', 'stack', 'constructor', 'toJSON')
+    , props = extend(_props || {});
+  // default values
+  this.message = message || 'Unspecified AssertionError';
+  this.showDiff = false;
+  // copy from properties
+  for (var key in props) {
+    this[key] = props[key];
+  }
+  // capture stack trace
+  ssf = ssf || arguments.callee;
+  if (ssf && Error.captureStackTrace) {
+    Error.captureStackTrace(this, ssf);
+  }
+}
 /*!
- * Primary `Assertion` prototype
+ * Inherit from Error.prototype
  */
-exports.Assertion = require('./chai/assertion');
+AssertionError.prototype = Object.create(Error.prototype);
 /*!
- * Assertion Error
+ * Statically set name
  */
-exports.AssertionError = require('./chai/error');
+AssertionError.prototype.name = 'AssertionError';
 /*!
- * Utils for plugins (not exported)
+ * Ensure correct constructor
  */
-var util = require('./chai/utils');
+AssertionError.prototype.constructor = AssertionError;
 /**
- * # .use(function)
+ * Allow errors to be converted to JSON for static transfer.
  *
- * Provides a way to extend the internals of Chai
- *
- * @param {Function}
- * @returns {this} for chaining
- * @api public
+ * @param {Boolean} include stack (default: `true`)
+ * @return {Object} object that can be `JSON.stringify`
  */
-exports.use = function (fn) {
-  if (!~used.indexOf(fn)) {
-    fn(this, util);
-    used.push(fn);
+AssertionError.prototype.toJSON = function (stack) {
+  var extend = exclude('constructor', 'toJSON', 'stack')
+    , props = extend({ name: this.name }, this);
+  // include stack if exists and not turned off
+  if (false !== stack && this.stack) {
+    props.stack = this.stack;
   }
-  return this;
+  return props;
 };
+});
+require.register("chaijs-type-detect/lib/type.js", function(exports, require, module){
 /*!
- * Core Assertions
+ * type-detect
+ * Copyright(c) 2013 jake luer <jake@alogicalparadox.com>
+ * MIT Licensed
  */
-var core = require('./chai/core/assertions');
-exports.use(core);
 /*!
- * Expect interface
+ * Primary Exports
  */
-var expect = require('./chai/interface/expect');
-exports.use(expect);
+var exports = module.exports = getType;
 /*!
- * Should interface
+ * Detectable javascript natives
  */
-var should = require('./chai/interface/should');
-exports.use(should);
+var natives = {
+    '[object Array]': 'array'
+  , '[object RegExp]': 'regexp'
+  , '[object Function]': 'function'
+  , '[object Arguments]': 'arguments'
+  , '[object Date]': 'date'
+};
-/*!
- * Assert interface
+/**
+ * ### typeOf (obj)
+ *
+ * Use several different techniques to determine
+ * the type of object being tested.
+ *
+ *
+ * @param {Mixed} object
+ * @return {String} object type
+ * @api public
  */
-var assert = require('./chai/interface/assert');
-exports.use(assert);
+function getType (obj) {
+  var str = Object.prototype.toString.call(obj);
+  if (natives[str]) return natives[str];
+  if (obj === null) return 'null';
+  if (obj === undefined) return 'undefined';
+  if (obj === Object(obj)) return 'object';
+  return typeof obj;
+}
+exports.Library = Library;
+/**
+ * ### Library
+ *
+ * Create a repository for custom type detection.
+ *
+ * ```js
+ * var lib = new type.Library;
+ * ```
+ *
+ */
+function Library () {
+  this.tests = {};
+}
+/**
+ * #### .of (obj)
+ *
+ * Expose replacement `typeof` detection to the library.
+ *
+ * ```js
+ * if ('string' === lib.of('hello world')) {
+ *   // ...
+ * }
+ * ```
+ *
+ * @param {Mixed} object to test
+ * @return {String} type
+ */
+Library.prototype.of = getType;
+/**
+ * #### .define (type, test)
+ *
+ * Add a test to for the `.test()` assertion.
+ *
+ * Can be defined as a regular expression:
+ *
+ * ```js
+ * lib.define('int', /^[0-9]+$/);
+ * ```
+ *
+ * ... or as a function:
+ *
+ * ```js
+ * lib.define('bln', function (obj) {
+ *   if ('boolean' === lib.of(obj)) return true;
+ *   var blns = [ 'yes', 'no', 'true', 'false', 1, 0 ];
+ *   if ('string' === lib.of(obj)) obj = obj.toLowerCase();
+ *   return !! ~blns.indexOf(obj);
+ * });
+ * ```
+ *
+ * @param {String} type
+ * @param {RegExp|Function} test
+ * @api public
+ */
+Library.prototype.define = function (type, test) {
+  if (arguments.length === 1) return this.tests[type];
+  this.tests[type] = test;
+  return this;
+};
+/**
+ * #### .test (obj, test)
+ *
+ * Assert that an object is of type. Will first
+ * check natives, and if that does not pass it will
+ * use the user defined custom tests.
+ *
+ * ```js
+ * assert(lib.test('1', 'int'));
+ * assert(lib.test('yes', 'bln'));
+ * ```
+ *
+ * @param {Mixed} object
+ * @param {String} type
+ * @return {Boolean} result
+ * @api public
+ */
+Library.prototype.test = function (obj, type) {
+  if (type === getType(obj)) return true;
+  var test = this.tests[type];
+  if (test && 'regexp' === getType(test)) {
+    return test.test(obj);
+  } else if (test && 'function' === getType(test)) {
+    return test(obj);
+  } else {
+    throw new ReferenceError('Type test "' + type + '" not defined or invalid.');
+  }
+};
 });
-require.register("chai/lib/chai/assertion.js", function(exports, require, module){
+require.register("chaijs-deep-eql/lib/eql.js", function(exports, require, module){
 /*!
- * chai
- * http://chaijs.com
- * Copyright(c) 2011-2013 Jake Luer <jake@alogicalparadox.com>
+ * deep-eql
+ * Copyright(c) 2013 Jake Luer <jake@alogicalparadox.com>
  * MIT Licensed
  */
 /*!
- * Module dependencies.
+ * Module dependencies
  */
-var AssertionError = require('./error')
-  , util = require('./utils')
-  , flag = util.flag;
+var type = require('type-detect');
 /*!
- * Module export.
+ * Buffer.isBuffer browser shim
  */
-module.exports = Assertion;
+var Buffer;
+try { Buffer = require('buffer').Buffer; }
+catch(ex) {
+  Buffer = {};
+  Buffer.isBuffer = function() { return false; }
+}
+/*!
+ * Primary Export
+ */
+module.exports = deepEqual;
+/**
+ * Assert super-strict (egal) equality between
+ * two objects of any type.
+ *
+ * @param {Mixed} a
+ * @param {Mixed} b
+ * @param {Array} memoised (optional)
+ * @return {Boolean} equal match
+ */
+function deepEqual(a, b, m) {
+  if (sameValue(a, b)) {
+    return true;
+  } else if ('date' === type(a)) {
+    return dateEqual(a, b);
+  } else if ('regexp' === type(a)) {
+    return regexpEqual(a, b);
+  } else if (Buffer.isBuffer(a)) {
+    return bufferEqual(a, b);
+  } else if ('arguments' === type(a)) {
+    return argumentsEqual(a, b, m);
+  } else if (!typeEqual(a, b)) {
+    return false;
+  } else if (('object' !== type(a) && 'object' !== type(b))
+  && ('array' !== type(a) && 'array' !== type(b))) {
+    return sameValue(a, b);
+  } else {
+    return objectEqual(a, b, m);
+  }
+}
 /*!
- * Assertion Constructor
+ * Strict (egal) equality test. Ensures that NaN always
+ * equals NaN and `-0` does not equal `+0`.
  *
- * Creates object for chaining.
+ * @param {Mixed} a
+ * @param {Mixed} b
+ * @return {Boolean} equal match
+ */
+function sameValue(a, b) {
+  if (a === b) return a !== 0 || 1 / a === 1 / b;
+  return a !== a && b !== b;
+}
+/*!
+ * Compare the types of two given objects and
+ * return if they are equal. Note that an Array
+ * has a type of `array` (not `object`) and arguments
+ * have a type of `arguments` (not `array`/`object`).
  *
- * @api private
+ * @param {Mixed} a
+ * @param {Mixed} b
+ * @return {Boolean} result
  */
-function Assertion (obj, msg, stack) {
-  flag(this, 'ssfi', stack || arguments.callee);
-  flag(this, 'object', obj);
-  flag(this, 'message', msg);
+function typeEqual(a, b) {
+  return type(a) === type(b);
 }
 /*!
-  * ### Assertion.includeStack
-  *
-  * User configurable property, influences whether stack trace
-  * is included in Assertion error message. Default of false
-  * suppresses stack trace in the error message
-  *
-  *     Assertion.includeStack = true;  // enable stack on error
-  *
-  * @api public
-  */
-Assertion.includeStack = false;
+ * Compare two Date objects by asserting that
+ * the time values are equal using `saveValue`.
+ *
+ * @param {Date} a
+ * @param {Date} b
+ * @return {Boolean} result
+ */
+function dateEqual(a, b) {
+  if ('date' !== type(b)) return false;
+  return sameValue(a.getTime(), b.getTime());
+}
 /*!
- * ### Assertion.showDiff
+ * Compare two regular expressions by converting them
+ * to string and checking for `sameValue`.
  *
- * User configurable property, influences whether or not
- * the `showDiff` flag should be included in the thrown
- * AssertionErrors. `false` will always be `false`; `true`
- * will be true when the assertion has requested a diff
- * be shown.
+ * @param {RegExp} a
+ * @param {RegExp} b
+ * @return {Boolean} result
+ */
+function regexpEqual(a, b) {
+  if ('regexp' !== type(b)) return false;
+  return sameValue(a.toString(), b.toString());
+}
+/*!
+ * Assert deep equality of two `arguments` objects.
+ * Unfortunately, these must be sliced to arrays
+ * prior to test to ensure no bad behavior.
  *
- * @api public
+ * @param {Arguments} a
+ * @param {Arguments} b
+ * @param {Array} memoize (optional)
+ * @return {Boolean} result
  */
-Assertion.showDiff = true;
+function argumentsEqual(a, b, m) {
+  if ('arguments' !== type(b)) return false;
+  a = [].slice.call(a);
+  b = [].slice.call(b);
+  return deepEqual(a, b, m);
+}
-Assertion.addProperty = function (name, fn) {
-  util.addProperty(this.prototype, name, fn);
-};
+/*!
+ * Get enumerable properties of a given object.
+ *
+ * @param {Object} a
+ * @return {Array} property names
+ */
-Assertion.addMethod = function (name, fn) {
-  util.addMethod(this.prototype, name, fn);
-};
+function enumerable(a) {
+  var res = [];
+  for (var key in a) res.push(key);
+  return res;
+}
-Assertion.addChainableMethod = function (name, fn, chainingBehavior) {
-  util.addChainableMethod(this.prototype, name, fn, chainingBehavior);
-};
+/*!
+ * Simple equality for flat iterable objects
+ * such as Arrays or Node.js buffers.
+ *
+ * @param {Iterable} a
+ * @param {Iterable} b
+ * @return {Boolean} result
+ */
-Assertion.overwriteProperty = function (name, fn) {
-  util.overwriteProperty(this.prototype, name, fn);
-};
+function iterableEqual(a, b) {
+  if (a.length !==  b.length) return false;
-Assertion.overwriteMethod = function (name, fn) {
-  util.overwriteMethod(this.prototype, name, fn);
-};
+  var i = 0;
+  var match = true;
+  for (; i < a.length; i++) {
+    if (a[i] !== b[i]) {
+      match = false;
+      break;
+    }
+  }
+  return match;
+}
 /*!
- * ### .assert(expression, message, negateMessage, expected, actual)
+ * Extension to `iterableEqual` specifically
+ * for Node.js Buffers.
  *
- * 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
- * @param {Mixed} expected value (remember to check for negation)
- * @param {Mixed} actual (optional) will default to `this.obj`
- * @api private
+ * @param {Buffer} a
+ * @param {Mixed} b
+ * @return {Boolean} result
  */
-Assertion.prototype.assert = function (expr, msg, negateMsg, expected, _actual, showDiff) {
-  var ok = util.test(this, arguments);
-  if (true !== showDiff) showDiff = false;
-  if (true !== Assertion.showDiff) showDiff = false;
-  if (!ok) {
-    var msg = util.getMessage(this, arguments)
-      , actual = util.getActual(this, arguments);
-    throw new AssertionError({
-        message: msg
-      , actual: actual
-      , expected: expected
-      , stackStartFunction: (Assertion.includeStack) ? this.assert : flag(this, 'ssfi')
-      , showDiff: showDiff
-    });
-  }
-};
+function bufferEqual(a, b) {
+  if (!Buffer.isBuffer(b)) return false;
+  return iterableEqual(a, b);
+}
 /*!
- * ### ._obj
+ * Block for `objectEqual` ensuring non-existing
+ * values don't get in.
  *
- * Quick reference to stored `actual` value for plugin developers.
+ * @param {Mixed} object
+ * @return {Boolean} result
+ */
+function isValue(a) {
+  return a !== null && a !== undefined;
+}
+/*!
+ * Recursively check the equality of two objects.
+ * Once basic sameness has been established it will
+ * defer to `deepEqual` for each enumerable key
+ * in the object.
  *
- * @api private
+ * @param {Mixed} a
+ * @param {Mixed} b
+ * @return {Boolean} result
  */
-Object.defineProperty(Assertion.prototype, '_obj',
-  { get: function () {
-      return flag(this, 'object');
+function objectEqual(a, b, m) {
+  if (!isValue(a) || !isValue(b)) {
+    return false;
+  }
+  if (a.prototype !== b.prototype) {
+    return false;
+  }
+  var i;
+  if (m) {
+    for (i = 0; i < m.length; i++) {
+      if ((m[i][0] === a && m[i][1] === b)
+      ||  (m[i][0] === b && m[i][1] === a)) {
+        return true;
+      }
     }
-  , set: function (val) {
-      flag(this, 'object', val);
+  } else {
+    m = [];
+  }
+  try {
+    var ka = enumerable(a);
+    var kb = enumerable(b);
+  } catch (ex) {
+    return false;
+  }
+  ka.sort();
+  kb.sort();
+  if (!iterableEqual(ka, kb)) {
+    return false;
+  }
+  m.push([ a, b ]);
+  var key;
+  for (i = ka.length - 1; i >= 0; i--) {
+    key = ka[i];
+    if (!deepEqual(a[key], b[key], m)) {
+      return false;
     }
+  }
+  return true;
+}
 });
+require.register("chai/index.js", function(exports, require, module){
+module.exports = require('./lib/chai');
 });
-require.register("chai/lib/chai/error.js", function(exports, require, module){
+require.register("chai/lib/chai.js", function(exports, require, module){
 /*!
  * chai
- * Copyright(c) 2011-2013 Jake Luer <jake@alogicalparadox.com>
+ * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
  * MIT Licensed
  */
+var used = []
+  , exports = module.exports = {};
 /*!
- * Main export
+ * Chai version
  */
-module.exports = AssertionError;
+exports.version = '1.8.1';
+/*!
+ * Assertion Error
+ */
+exports.AssertionError = require('assertion-error');
+/*!
+ * Utils for plugins (not exported)
+ */
+var util = require('./chai/utils');
 /**
- * # AssertionError (constructor)
- *
- * Create a new assertion error based on the Javascript
- * `Error` prototype.
+ * # .use(function)
  *
- * **Options**
- * - message
- * - actual
- * - expected
- * - operator
- * - startStackFunction
+ * Provides a way to extend the internals of Chai
  *
- * @param {Object} options
+ * @param {Function}
+ * @returns {this} for chaining
  * @api public
  */
-function AssertionError (options) {
-  options = options || {};
-  this.message = options.message;
-  this.actual = options.actual;
-  this.expected = options.expected;
-  this.operator = options.operator;
-  this.showDiff = options.showDiff;
-  if (options.stackStartFunction && Error.captureStackTrace) {
-    var stackStartFunction = options.stackStartFunction;
-    Error.captureStackTrace(this, stackStartFunction);
+exports.use = function (fn) {
+  if (!~used.indexOf(fn)) {
+    fn(this, util);
+    used.push(fn);
   }
-}
+  return this;
+};
 /*!
- * Inherit from Error
+ * Primary `Assertion` prototype
  */
-AssertionError.prototype = Object.create(Error.prototype);
-AssertionError.prototype.name = 'AssertionError';
-AssertionError.prototype.constructor = AssertionError;
+var assertion = require('./chai/assertion');
+exports.use(assertion);
-/**
- * # toString()
- *
- * Override default to string method
+/*!
+ * Core Assertions
+ */
+var core = require('./chai/core/assertions');
+exports.use(core);
+/*!
+ * Expect interface
+ */
+var expect = require('./chai/interface/expect');
+exports.use(expect);
+/*!
+ * Should interface
  */
-AssertionError.prototype.toString = function() {
-  return this.message;
+var should = require('./chai/interface/should');
+exports.use(should);
+/*!
+ * Assert interface
+ */
+var assert = require('./chai/interface/assert');
+exports.use(assert);
+});
+require.register("chai/lib/chai/assertion.js", function(exports, require, module){
+/*!
+ * chai
+ * http://chaijs.com
+ * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+module.exports = function (_chai, util) {
+  /*!
+   * Module dependencies.
+   */
+  var AssertionError = _chai.AssertionError
+    , flag = util.flag;
+  /*!
+   * Module export.
+   */
+  _chai.Assertion = Assertion;
+  /*!
+   * Assertion Constructor
+   *
+   * Creates object for chaining.
+   *
+   * @api private
+   */
+  function Assertion (obj, msg, stack) {
+    flag(this, 'ssfi', stack || arguments.callee);
+    flag(this, 'object', obj);
+    flag(this, 'message', msg);
+  }
+  /*!
+    * ### Assertion.includeStack
+    *
+    * User configurable property, influences whether stack trace
+    * is included in Assertion error message. Default of false
+    * suppresses stack trace in the error message
+    *
+    *     Assertion.includeStack = true;  // enable stack on error
+    *
+    * @api public
+    */
+  Assertion.includeStack = false;
+  /*!
+   * ### Assertion.showDiff
+   *
+   * User configurable property, influences whether or not
+   * the `showDiff` flag should be included in the thrown
+   * AssertionErrors. `false` will always be `false`; `true`
+   * will be true when the assertion has requested a diff
+   * be shown.
+   *
+   * @api public
+   */
+  Assertion.showDiff = true;
+  Assertion.addProperty = function (name, fn) {
+    util.addProperty(this.prototype, name, fn);
+  };
+  Assertion.addMethod = function (name, fn) {
+    util.addMethod(this.prototype, name, fn);
+  };
+  Assertion.addChainableMethod = function (name, fn, chainingBehavior) {
+    util.addChainableMethod(this.prototype, name, fn, chainingBehavior);
+  };
+  Assertion.overwriteProperty = function (name, fn) {
+    util.overwriteProperty(this.prototype, name, fn);
+  };
+  Assertion.overwriteMethod = function (name, fn) {
+    util.overwriteMethod(this.prototype, name, fn);
+  };
+  Assertion.overwriteChainableMethod = function (name, fn, chainingBehavior) {
+    util.overwriteChainableMethod(this.prototype, name, fn, chainingBehavior);
+  };
+  /*!
+   * ### .assert(expression, message, negateMessage, expected, actual)
+   *
+   * 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
+   * @param {Mixed} expected value (remember to check for negation)
+   * @param {Mixed} actual (optional) will default to `this.obj`
+   * @api private
+   */
+  Assertion.prototype.assert = function (expr, msg, negateMsg, expected, _actual, showDiff) {
+    var ok = util.test(this, arguments);
+    if (true !== showDiff) showDiff = false;
+    if (true !== Assertion.showDiff) showDiff = false;
+    if (!ok) {
+      var msg = util.getMessage(this, arguments)
+        , actual = util.getActual(this, arguments);
+      throw new AssertionError(msg, {
+          actual: actual
+        , expected: expected
+        , showDiff: showDiff
+      }, (Assertion.includeStack) ? this.assert : flag(this, 'ssfi'));
+    }
+  };
+  /*!
+   * ### ._obj
+   *
+   * Quick reference to stored `actual` value for plugin developers.
+   *
+   * @api private
+   */
+  Object.defineProperty(Assertion.prototype, '_obj',
+    { get: function () {
+        return flag(this, 'object');
+      }
+    , set: function (val) {
+        flag(this, 'object', val);
+      }
+  });
 };
 });
@@ -488,7 +946,7 @@ require.register("chai/lib/chai/core/assertions.js", function(exports, require,
 /*!
  * chai
  * http://chaijs.com
- * Copyright(c) 2011-2013 Jake Luer <jake@alogicalparadox.com>
+ * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
  * MIT Licensed
  */
@@ -500,7 +958,7 @@ module.exports = function (chai, _) {
   /**
    * ### Language Chains
    *
-   * The following are provide as chainable getters to
+   * The following are provided as chainable getters to
    * improve the readability of your assertions. They
    * do not provide an testing capability unless they
    * have been overwritten by a plugin.
@@ -513,6 +971,7 @@ module.exports = function (chai, _) {
    * - is
    * - that
    * - and
+   * - has
    * - have
    * - with
    * - at
@@ -524,7 +983,7 @@ module.exports = function (chai, _) {
    */
   [ 'to', 'be', 'been'
-  , 'is', 'and', 'have'
+  , 'is', 'and', 'has', 'have'
   , 'with', 'that', 'at'
   , 'of', 'same' ].forEach(function (chain) {
     Assertion.addProperty(chain, function () {
@@ -632,9 +1091,21 @@ module.exports = function (chai, _) {
   function include (val, msg) {
     if (msg) flag(this, 'message', msg);
-    var obj = flag(this, 'object')
+    var obj = flag(this, 'object');
+    if (_.type(val) === 'object') {
+      if (!flag(this, 'negate')) {
+        for (var k in val) new Assertion(obj).property(k, val[k]);
+        return;
+      }
+      var subset = {}
+      for (var k in val) subset[k] = obj[k]
+      var expected = _.eql(subset, val);
+    } else {
+      var expected = obj && ~obj.indexOf(val)
+    }
     this.assert(
-        ~obj.indexOf(val)
+        expected
       , 'expected #{this} to include ' + _.inspect(val)
       , 'expected #{this} to not include ' + _.inspect(val));
   }
@@ -731,8 +1202,8 @@ module.exports = function (chai, _) {
    *
    * Asserts that the target is `undefined`.
    *
-   *      expect(undefined).to.be.undefined;
-   *      expect(null).to.not.be.undefined;
+   *     expect(undefined).to.be.undefined;
+   *     expect(null).to.not.be.undefined;
    *
    * @name undefined
    * @api public
@@ -1489,6 +1960,7 @@ module.exports = function (chai, _) {
    * @param {String|RegExp} expected error message
    * @param {String} message _optional_
    * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types
+   * @returns error for chaining (null if no error)
    * @api public
    */
@@ -1513,7 +1985,10 @@ module.exports = function (chai, _) {
       constructor = null;
       errMsg = null;
     } else if (typeof constructor === 'function') {
-      name = (new constructor()).name;
+      name = constructor.prototype.name || constructor.name;
+      if (name === 'Error' && constructor !== Error) {
+        name = (new constructor()).name;
+      }
     } else {
       constructor = null;
     }
@@ -1527,12 +2002,14 @@ module.exports = function (chai, _) {
             err === desiredError
           , 'expected #{this} to throw #{exp} but #{act} was thrown'
           , 'expected #{this} to not throw #{exp}'
-          , desiredError
-          , err
+          , (desiredError instanceof Error ? desiredError.toString() : desiredError)
+          , (err instanceof Error ? err.toString() : err)
         );
+        flag(this, 'object', err);
         return this;
       }
       // next, check constructor
       if (constructor) {
         this.assert(
@@ -1540,11 +2017,15 @@ module.exports = function (chai, _) {
           , 'expected #{this} to throw #{exp} but #{act} was thrown'
           , 'expected #{this} to not throw #{exp} but #{act} was thrown'
           , name
-          , err
+          , (err instanceof Error ? err.toString() : err)
         );
-        if (!errMsg) return this;
+        if (!errMsg) {
+          flag(this, 'object', err);
+          return this;
+        }
       }
       // next, check message
       var message = 'object' === _.type(err) && "message" in err
         ? err.message
@@ -1559,6 +2040,7 @@ module.exports = function (chai, _) {
           , message
         );
+        flag(this, 'object', err);
         return this;
       } else if ((message != null) && errMsg && 'string' === typeof errMsg) {
         this.assert(
@@ -1569,6 +2051,7 @@ module.exports = function (chai, _) {
           , message
         );
+        flag(this, 'object', err);
         return this;
       } else {
         thrown = true;
@@ -1591,9 +2074,11 @@ module.exports = function (chai, _) {
         thrown === true
       , 'expected #{this} to throw ' + expectedThrown + actuallyGot
       , 'expected #{this} to not throw ' + expectedThrown + actuallyGot
-      , desiredError
-      , thrownError
+      , (desiredError instanceof Error ? desiredError.toString() : desiredError)
+      , (thrownError instanceof Error ? thrownError.toString() : thrownError)
     );
+    flag(this, 'object', thrownError);
   };
   Assertion.addMethod('throw', assertThrows);
@@ -1612,8 +2097,8 @@ module.exports = function (chai, _) {
    * To check if a constructor will respond to a static function,
    * set the `itself` flag.
    *
-   *    Klass.baz = function(){};
-   *    expect(Klass).itself.to.respondTo('baz');
+   *     Klass.baz = function(){};
+   *     expect(Klass).itself.to.respondTo('baz');
    *
    * @name respondTo
    * @param {String} method
@@ -1641,12 +2126,12 @@ module.exports = function (chai, _) {
    *
    * Sets the `itself` flag, later used by the `respondTo` assertion.
    *
-   *    function Foo() {}
-   *    Foo.bar = function() {}
-   *    Foo.prototype.baz = function() {}
+   *     function Foo() {}
+   *     Foo.bar = function() {}
+   *     Foo.prototype.baz = function() {}
    *
-   *    expect(Foo).itself.to.respondTo('bar');
-   *    expect(Foo).itself.not.to.respondTo('baz');
+   *     expect(Foo).itself.to.respondTo('bar');
+   *     expect(Foo).itself.not.to.respondTo('baz');
    *
    * @name itself
    * @api public
@@ -1712,16 +2197,16 @@ module.exports = function (chai, _) {
   }
   /**
-   * ### .members
+   * ### .members(set)
    *
    * Asserts that the target is a superset of `set`,
    * or that the target and `set` have the same members.
    *
-   *    expect([1, 2, 3]).to.include.members([3, 2]);
-   *    expect([1, 2, 3]).to.not.include.members([3, 2, 8]);
+   *     expect([1, 2, 3]).to.include.members([3, 2]);
+   *     expect([1, 2, 3]).to.not.include.members([3, 2, 8]);
    *
-   *    expect([4, 2]).to.have.members([2, 4]);
-   *    expect([5, 2]).to.not.have.members([5, 2, 1]);
+   *     expect([4, 2]).to.have.members([2, 4]);
+   *     expect([5, 2]).to.not.have.members([5, 2, 1]);
    *
    * @name members
    * @param {Array} set
@@ -1760,7 +2245,7 @@ module.exports = function (chai, _) {
 require.register("chai/lib/chai/interface/assert.js", function(exports, require, module){
 /*!
  * chai
- * Copyright(c) 2011-2013 Jake Luer <jake@alogicalparadox.com>
+ * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
  * MIT Licensed
  */
@@ -1815,13 +2300,12 @@ module.exports = function (chai, util) {
    */
   assert.fail = function (actual, expected, message, operator) {
-    throw new chai.AssertionError({
+    message = message || 'assert.fail()';
+    throw new chai.AssertionError(message, {
         actual: actual
       , expected: expected
-      , message: message
       , operator: operator
-      , stackStartFunction: assert.fail
-    });
+    }, assert.fail);
   };
   /**
@@ -1842,6 +2326,24 @@ module.exports = function (chai, util) {
     new Assertion(val, msg).is.ok;
   };
+  /**
+   * ### .notOk(object, [message])
+   *
+   * Asserts that `object` is falsy.
+   *
+   *     assert.notOk('everything', 'this will fail');
+   *     assert.notOk(false, 'this will pass');
+   *
+   * @name notOk
+   * @param {Mixed} object to test
+   * @param {String} message
+   * @api public
+   */
+  assert.notOk = function (val, msg) {
+    new Assertion(val, msg).is.not.ok;
+  };
   /**
    * ### .equal(actual, expected, [message])
    *
@@ -2063,7 +2565,7 @@ module.exports = function (chai, util) {
    *     var tea = 'cup of chai';
    *     assert.isDefined(tea, 'tea has been defined');
    *
-   * @name isUndefined
+   * @name isDefined
    * @param {Mixed} value
    * @param {String} message
    * @api public
@@ -2399,18 +2901,7 @@ module.exports = function (chai, util) {
    */
   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);
-    } else {
-      throw new chai.AssertionError({
-          message: 'expected an array or string'
-        , stackStartFunction: assert.include
-      });
-    }
+    new Assertion(exp, msg).include(inc);
   };
   /**
@@ -2430,18 +2921,7 @@ module.exports = function (chai, util) {
    */
   assert.notInclude = function (exp, inc, msg) {
-    var obj = new Assertion(exp, msg);
-    if (Array.isArray(exp)) {
-      obj.to.not.include(inc);
-    } else if ('string' === typeof exp) {
-      obj.to.not.contain.string(inc);
-    } else {
-      throw new chai.AssertionError({
-          message: 'expected an array or string'
-        , stackStartFunction: assert.include
-      });
-    }
+    new Assertion(exp, msg).not.include(inc);
   };
   /**
@@ -2685,7 +3165,8 @@ module.exports = function (chai, util) {
       errt = null;
     }
-    new Assertion(fn, msg).to.Throw(errt, errs);
+    var assertErr = new Assertion(fn, msg).to.Throw(errt, errs);
+    return flag(assertErr, 'object');
   };
   /**
@@ -2823,7 +3304,7 @@ module.exports = function (chai, util) {
 require.register("chai/lib/chai/interface/expect.js", function(exports, require, module){
 /*!
  * chai
- * Copyright(c) 2011-2013 Jake Luer <jake@alogicalparadox.com>
+ * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
  * MIT Licensed
  */
@@ -2838,7 +3319,7 @@ module.exports = function (chai, util) {
 require.register("chai/lib/chai/interface/should.js", function(exports, require, module){
 /*!
  * chai
- * Copyright(c) 2011-2013 Jake Luer <jake@alogicalparadox.com>
+ * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
  * MIT Licensed
  */
@@ -2917,7 +3398,7 @@ module.exports = function (chai, util) {
 require.register("chai/lib/chai/utils/addChainableMethod.js", function(exports, require, module){
 /*!
  * Chai - addChainingMethod utility
- * Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
+ * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
  * MIT Licensed
  */
@@ -2972,15 +3453,27 @@ var call  = Function.prototype.call,
  */
 module.exports = function (ctx, name, method, chainingBehavior) {
-  if (typeof chainingBehavior !== 'function')
+  if (typeof chainingBehavior !== 'function') {
     chainingBehavior = function () { };
+  }
+  var chainableBehavior = {
+      method: method
+    , chainingBehavior: chainingBehavior
+  };
+  // save the methods so we can overwrite them later, if we need to.
+  if (!ctx.__methods) {
+    ctx.__methods = {};
+  }
+  ctx.__methods[name] = chainableBehavior;
   Object.defineProperty(ctx, name,
     { get: function () {
-        chainingBehavior.call(this);
+        chainableBehavior.chainingBehavior.call(this);
         var assert = function () {
-          var result = method.apply(this, arguments);
+          var result = chainableBehavior.method.apply(this, arguments);
           return result === undefined ? this : result;
         };
@@ -3014,7 +3507,7 @@ module.exports = function (ctx, name, method, chainingBehavior) {
 require.register("chai/lib/chai/utils/addMethod.js", function(exports, require, module){
 /*!
  * Chai - addMethod utility
- * Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
+ * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
  * MIT Licensed
  */
@@ -3054,7 +3547,7 @@ module.exports = function (ctx, name, method) {
 require.register("chai/lib/chai/utils/addProperty.js", function(exports, require, module){
 /*!
  * Chai - addProperty utility
- * Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
+ * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
  * MIT Licensed
  */
@@ -3093,138 +3586,11 @@ module.exports = function (ctx, name, getter) {
   });
 };
-});
-require.register("chai/lib/chai/utils/eql.js", function(exports, require, module){
-// This is (almost) directly from Node.js assert
-// https://github.com/joyent/node/blob/f8c335d0caf47f16d31413f89aa28eda3878e3aa/lib/assert.js
-module.exports = _deepEqual;
-var getEnumerableProperties = require('./getEnumerableProperties');
-// for the browser
-var Buffer;
-try {
-  Buffer = require('buffer').Buffer;
-} catch (ex) {
-  Buffer = {
-    isBuffer: function () { return false; }
-  };
-}
-function _deepEqual(actual, expected, memos) {
-  // 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, memos);
-  }
-}
-function isUndefinedOrNull(value) {
-  return value === null || value === undefined;
-}
-function isArguments(object) {
-  return Object.prototype.toString.call(object) == '[object Arguments]';
-}
-function objEquiv(a, b, memos) {
-  if (isUndefinedOrNull(a) || isUndefinedOrNull(b))
-    return false;
-  // an identical 'prototype' property.
-  if (a.prototype !== b.prototype) return false;
-  // check if we have already compared a and b
-  var i;
-  if (memos) {
-    for(i = 0; i < memos.length; i++) {
-      if ((memos[i][0] === a && memos[i][1] === b) ||
-          (memos[i][0] === b && memos[i][1] === a))
-        return true;
-    }
-  } else {
-    memos = [];
-  }
-  //~~~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, memos);
-  }
-  try {
-    var ka = getEnumerableProperties(a),
-        kb = getEnumerableProperties(b),
-        key;
-  } 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;
-  }
-  // remember objects we have compared to guard against circular references
-  memos.push([ a, b ]);
-  //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], memos)) return false;
-  }
-  return true;
-}
 });
 require.register("chai/lib/chai/utils/flag.js", function(exports, require, module){
 /*!
  * Chai - flag utility
- * Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
+ * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
  * MIT Licensed
  */
@@ -3259,7 +3625,7 @@ module.exports = function (obj, key, value) {
 require.register("chai/lib/chai/utils/getActual.js", function(exports, require, module){
 /*!
  * Chai - getActual utility
- * Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
+ * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
  * MIT Licensed
  */
@@ -3281,7 +3647,7 @@ module.exports = function (obj, args) {
 require.register("chai/lib/chai/utils/getEnumerableProperties.js", function(exports, require, module){
 /*!
  * Chai - getEnumerableProperties utility
- * Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
+ * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
  * MIT Licensed
  */
@@ -3309,7 +3675,7 @@ module.exports = function getEnumerableProperties(object) {
 require.register("chai/lib/chai/utils/getMessage.js", function(exports, require, module){
 /*!
  * Chai - message composition utility
- * Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
+ * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
  * MIT Licensed
  */
@@ -3329,7 +3695,7 @@ var flag = require('./flag')
  * and template tags. Template tags will return
  * a stringified inspection of the object referenced.
  *
- * Messsage template tags:
+ * Message template tags:
  * - `#{this}` current asserted object
  * - `#{act}` actual value
  * - `#{exp}` expected value
@@ -3361,7 +3727,7 @@ module.exports = function (obj, args) {
 require.register("chai/lib/chai/utils/getName.js", function(exports, require, module){
 /*!
  * Chai - getName utility
- * Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
+ * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
  * MIT Licensed
  */
@@ -3384,7 +3750,7 @@ module.exports = function (func) {
 require.register("chai/lib/chai/utils/getPathValue.js", function(exports, require, module){
 /*!
  * Chai - getPathValue utility
- * Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
+ * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
  * @see https://github.com/logicalparadox/filtr
  * MIT Licensed
  */
@@ -3489,7 +3855,7 @@ function _getPathValue (parsed, obj) {
 require.register("chai/lib/chai/utils/getProperties.js", function(exports, require, module){
 /*!
  * Chai - getProperties utility
- * Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
+ * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
  * MIT Licensed
  */
@@ -3589,7 +3955,7 @@ exports.transferFlags = require('./transferFlags');
  * Deep equal utility
  */
-exports.eql = require('./eql');
+exports.eql = require('deep-eql');
 /*!
  * Deep path value
@@ -3633,6 +3999,12 @@ exports.overwriteMethod = require('./overwriteMethod');
 exports.addChainableMethod = require('./addChainableMethod');
+/*!
+ * Overwrite chainable method
+ */
+exports.overwriteChainableMethod = require('./overwriteChainableMethod');
 });
 require.register("chai/lib/chai/utils/inspect.js", function(exports, require, module){
@@ -3703,7 +4075,11 @@ function formatValue(ctx, value, recurseTimes) {
       value.inspect !== exports.inspect &&
       // Also filter out any prototype objects using the circular check.
       !(value.constructor && value.constructor.prototype === value)) {
-    return value.inspect(recurseTimes);
+    var ret = value.inspect(recurseTimes);
+    if (typeof ret !== 'string') {
+      ret = formatValue(ctx, ret, recurseTimes);
+    }
+    return ret;
   }
   // Primitive types cannot have properties
@@ -3957,7 +4333,7 @@ function objectToString(o) {
 require.register("chai/lib/chai/utils/objDisplay.js", function(exports, require, module){
 /*!
  * Chai - flag utility
- * Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
+ * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
  * MIT Licensed
  */
@@ -4008,7 +4384,7 @@ module.exports = function (obj) {
 require.register("chai/lib/chai/utils/overwriteMethod.js", function(exports, require, module){
 /*!
  * Chai - overwriteMethod utility
- * Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
+ * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
  * MIT Licensed
  */
@@ -4062,7 +4438,7 @@ module.exports = function (ctx, name, method) {
 require.register("chai/lib/chai/utils/overwriteProperty.js", function(exports, require, module){
 /*!
  * Chai - overwriteProperty utility
- * Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
+ * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
  * MIT Licensed
  */
@@ -4115,11 +4491,67 @@ module.exports = function (ctx, name, getter) {
   });
 };
+});
+require.register("chai/lib/chai/utils/overwriteChainableMethod.js", function(exports, require, module){
+/*!
+ * Chai - overwriteChainableMethod utility
+ * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+/**
+ * ### overwriteChainableMethod (ctx, name, fn)
+ *
+ * Overwites an already existing chainable method
+ * and provides access to the previous function or
+ * property.  Must return functions to be used for
+ * name.
+ *
+ *     utils.overwriteChainableMethod(chai.Assertion.prototype, 'length',
+ *       function (_super) {
+ *       }
+ *     , function (_super) {
+ *       }
+ *     );
+ *
+ * Can also be accessed directly from `chai.Assertion`.
+ *
+ *     chai.Assertion.overwriteChainableMethod('foo', fn, fn);
+ *
+ * Then can be used as any other assertion.
+ *
+ *     expect(myFoo).to.have.length(3);
+ *     expect(myFoo).to.have.length.above(3);
+ *
+ * @param {Object} ctx object whose method / property is to be overwritten
+ * @param {String} name of method / property to overwrite
+ * @param {Function} method function that returns a function to be used for name
+ * @param {Function} chainingBehavior function that returns a function to be used for property
+ * @name overwriteChainableMethod
+ * @api public
+ */
+module.exports = function (ctx, name, method, chainingBehavior) {
+  var chainableBehavior = ctx.__methods[name];
+  var _chainingBehavior = chainableBehavior.chainingBehavior;
+  chainableBehavior.chainingBehavior = function () {
+    var result = chainingBehavior(_chainingBehavior).call(this);
+    return result === undefined ? this : result;
+  };
+  var _method = chainableBehavior.method;
+  chainableBehavior.method = function () {
+    var result = method(_method).apply(this, arguments);
+    return result === undefined ? this : result;
+  };
+};
 });
 require.register("chai/lib/chai/utils/test.js", function(exports, require, module){
 /*!
  * Chai - test utility
- * Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
+ * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
  * MIT Licensed
  */
@@ -4148,7 +4580,7 @@ module.exports = function (obj, args) {
 require.register("chai/lib/chai/utils/transferFlags.js", function(exports, require, module){
 /*!
  * Chai - transferFlags utility
- * Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
+ * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
  * MIT Licensed
  */
@@ -4195,7 +4627,7 @@ module.exports = function (assertion, object, includeAll) {
 require.register("chai/lib/chai/utils/type.js", function(exports, require, module){
 /*!
  * Chai - type utility
- * Copyright(c) 2012-2013 Jake Luer <jake@alogicalparadox.com>
+ * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
  * MIT Licensed
  */
@@ -4240,12 +4672,25 @@ module.exports = function (obj) {
 };
 });
-require.alias("chai/index.js", "chai/index.js");
-if (typeof exports == "object") {
+require.alias("chaijs-assertion-error/index.js", "chai/deps/assertion-error/index.js");
+require.alias("chaijs-assertion-error/index.js", "chai/deps/assertion-error/index.js");
+require.alias("chaijs-assertion-error/index.js", "assertion-error/index.js");
+require.alias("chaijs-assertion-error/index.js", "chaijs-assertion-error/index.js");
+require.alias("chaijs-deep-eql/lib/eql.js", "chai/deps/deep-eql/lib/eql.js");
+require.alias("chaijs-deep-eql/lib/eql.js", "chai/deps/deep-eql/index.js");
+require.alias("chaijs-deep-eql/lib/eql.js", "deep-eql/index.js");
+require.alias("chaijs-type-detect/lib/type.js", "chaijs-deep-eql/deps/type-detect/lib/type.js");
+require.alias("chaijs-type-detect/lib/type.js", "chaijs-deep-eql/deps/type-detect/index.js");
+require.alias("chaijs-type-detect/lib/type.js", "chaijs-type-detect/index.js");
+require.alias("chaijs-deep-eql/lib/eql.js", "chaijs-deep-eql/index.js");
+require.alias("chai/index.js", "chai/index.js");if (typeof exports == "object") {
   module.exports = require("chai");
 } else if (typeof define == "function" && define.amd) {
-  define(function(){ return require("chai"); });
+  define([], function(){ return require("chai"); });
 } else {
   this["chai"] = require("chai");
 }})();