Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Browse files

Merge pull request #34 from joliss/add-assets

Add and unignore generated asset files. Fixes #33
  • Loading branch information...
commit 04456a2299f83d6b0f852405957a6e708183d414 2 parents 4046d5e + 4cbf46a
@joliss authored
View
3  .gitignore
@@ -18,6 +18,3 @@ test/version_tmp
tmp
node_modules
spec/dummy/log
-vendor/assets/javascripts/mocha.js
-vendor/assets/stylesheets/mocha.css
-vendor/assets/javascripts/chai.js
View
4 Rakefile
@@ -3,7 +3,7 @@
require "bundler/gem_tasks"
require "rspec/core/rake_task"
-RSpec::Core::RakeTask.new :spec => :assets
+RSpec::Core::RakeTask.new :spec
desc 'Build and copy Mocha and Chai assets from submodules into vendor/assets'
task :assets do
@@ -17,6 +17,4 @@ task :assets do
cp 'chai/chai.js', 'vendor/assets/javascripts/'
end
-task :build => :assets
-
task :default => :spec
View
3,151 vendor/assets/javascripts/chai.js
@@ -0,0 +1,3151 @@
+!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-2012 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 node.js and in all browsers.
+ *
+ * The `should` interface extends `Object.prototype` to provide a single getter as
+ * the starting point for your language assertions. It works on node.js and in
+ * all browsers except Internet Explorer.
+ *
+ * #### Configuration
+ *
+ * By default, Chai does not show stack traces upon an AssertionError. This can
+ * be changed by modifying the `includeStack` parameter for chai.Assertion. For example:
+ *
+ * var chai = require('chai');
+ * chai.Assertion.includeStack = true; // defaults to false
+ */
+
+/*!
+ * Module dependencies.
+ */
+
+var AssertionError = require('./browser/error')
+ , toString = Object.prototype.toString
+ , util = require('./utils')
+ , flag = util.flag;
+
+/*!
+ * Module export.
+ */
+
+module.exports = 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;
+
+/*!
+ * # .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) {
+ var msg = util.getMessage(this, arguments)
+ , actual = util.getActual(this, arguments)
+ , ok = util.test(this, arguments);
+
+ if (!ok) {
+ throw new AssertionError({
+ message: msg
+ , actual: actual
+ , expected: expected
+ , stackStartFunction: (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);
+ }
+});
+
+/**
+ * # 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 () {
+ flag(this, 'tense', 'past');
+ return this;
+ }
+ , configurable: true
+});
+
+/**
+ * # .a(type)
+ *
+ * Assert typeof. Also can be used as a language chain.
+ *
+ * expect('test').to.be.a('string');
+ * expect(foo).to.be.an.instanceof(Foo);
+ *
+ * @name a
+ * @alias an
+ * @param {String} type
+ * @api public
+ */
+
+var an = function () {
+ var assert = function(type) {
+ var obj = flag(this, 'object')
+ , klass = type.charAt(0).toUpperCase() + type.slice(1);
+
+ this.assert(
+ '[object ' + klass + ']' === toString.call(obj)
+ , 'expected #{this} to be a ' + type
+ , 'expected #{this} not to be a ' + type
+ , '[object ' + klass + ']'
+ , toString.call(obj)
+ );
+
+ return this;
+ };
+
+ assert.__proto__ = this;
+ return assert;
+};
+
+Object.defineProperty(Assertion.prototype, 'an',
+ { get: an
+ , configurable: true
+});
+
+Object.defineProperty(Assertion.prototype, 'a',
+ { get: an
+ , configurable: true
+});
+
+/**
+ * # .include(value)
+ *
+ * Assert the inclusion of an object in an Array or substring in string.
+ * Also toggles the `contain` flag for the `keys` assertion if used as property.
+ *
+ * expect([1,2,3]).to.include(2);
+ *
+ * @name include
+ * @alias contain
+ * @param {Object|String|Number} obj
+ * @api public
+ */
+var include = function () {
+ flag(this, 'contains', true);
+
+ var assert = function(val) {
+ var obj = flag(this, 'object')
+ this.assert(
+ ~obj.indexOf(val)
+ , 'expected #{this} to include ' + util.inspect(val)
+ , 'expected #{this} to not include ' + util.inspect(val));
+
+ return this;
+ };
+
+ assert.__proto__ = this;
+ return assert;
+};
+
+Object.defineProperty(Assertion.prototype, 'contain',
+ { get: include
+ , configurable: true
+});
+
+Object.defineProperty(Assertion.prototype, 'include',
+ { get: include
+ , 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 () {
+ flag(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(
+ flag(this, 'object')
+ , 'expected #{this} to be truthy'
+ , 'expected #{this} to be falsy');
+
+ return this;
+ }
+ , configurable: true
+});
+
+/**
+ * # .true
+ *
+ * Assert object is true
+ *
+ * @name true
+ * @api public
+ */
+
+Object.defineProperty(Assertion.prototype, 'true',
+ { get: function () {
+ this.assert(
+ true === flag(this, 'object')
+ , 'expected #{this} to be true'
+ , 'expected #{this} to be false'
+ , this.negate ? false : true
+ );
+
+ return this;
+ }
+ , configurable: true
+});
+
+/**
+ * # .false
+ *
+ * Assert object is false
+ *
+ * @name false
+ * @api public
+ */
+
+Object.defineProperty(Assertion.prototype, 'false',
+ { get: function () {
+ this.assert(
+ false === flag(this, 'object')
+ , 'expected #{this} to be false'
+ , 'expected #{this} to be true'
+ , this.negate ? true : false
+ );
+
+ return this;
+ }
+ , configurable: true
+});
+
+/**
+ * # .null
+ *
+ * Assert object is null
+ *
+ * @name null
+ * @api public
+ */
+
+Object.defineProperty(Assertion.prototype, 'null',
+ { get: function () {
+ this.assert(
+ null === flag(this, 'object')
+ , 'expected #{this} to be null'
+ , 'expected #{this} not to be null'
+ , this.negate ? false : true
+ );
+
+ return this;
+ }
+ , configurable: true
+});
+
+/**
+ * # .undefined
+ *
+ * Assert object is undefined
+ *
+ * @name undefined
+ * @api public
+ */
+
+Object.defineProperty(Assertion.prototype, 'undefined',
+ { get: function () {
+ this.assert(
+ undefined === flag(this, 'object')
+ , 'expected #{this} to be undefined'
+ , 'expected #{this} not to be undefined'
+ , this.negate ? false : 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 != flag(this, 'object')
+ , 'expected #{this} to exist'
+ , 'expected #{this} 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 () {
+ var obj = flag(this, 'object')
+ , expected = obj;
+
+ if (Array.isArray(obj)) {
+ expected = obj.length;
+ } else if (typeof obj === 'object') {
+ expected = Object.keys(obj).length;
+ }
+
+ this.assert(
+ !expected
+ , 'expected #{this} to be empty'
+ , 'expected #{this} 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 () {
+ var obj = flag(this, 'object');
+ this.assert(
+ '[object Arguments]' == Object.prototype.toString.call(obj)
+ , 'expected #{this} to be arguments'
+ , 'expected #{this} to not be arguments'
+ , '[object Arguments]'
+ , Object.prototype.toString.call(obj)
+ );
+
+ 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 === flag(this, 'object')
+ , 'expected #{this} to equal #{exp}'
+ , 'expected #{this} to not equal #{exp}'
+ , 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(
+ util.eql(obj, flag(this, 'object'))
+ , 'expected #{this} to equal #{exp}'
+ , 'expected #{this} to not equal #{exp}'
+ , obj );
+
+ return this;
+};
+
+/**
+ * # .above(value)
+ *
+ * Assert greater than `value`.
+ *
+ * expect(10).to.be.above(5);
+ *
+ * @name above
+ * @alias mt
+ * @param {Number} value
+ * @api public
+ */
+
+Assertion.prototype.above = function (val) {
+ this.assert(
+ flag(this, 'object') > val
+ , 'expected #{this} to be above ' + val
+ , 'expected #{this} to be below ' + val);
+
+ return this;
+};
+
+/**
+ * # .below(value)
+ *
+ * Assert less than `value`.
+ *
+ * expect(5).to.be.below(10);
+ *
+ * @name below
+ * @alias lt
+ * @param {Number} value
+ * @api public
+ */
+
+Assertion.prototype.below = function (val) {
+ this.assert(
+ flag(this, 'object') < val
+ , 'expected #{this} to be below ' + val
+ , 'expected #{this} 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 obj = flag(this, 'object')
+ , range = start + '..' + finish;
+
+ this.assert(
+ obj >= start && obj <= finish
+ , 'expected #{this} to be within ' + range
+ , 'expected #{this} to not be within ' + range);
+
+ 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 = util.getName(constructor);
+ this.assert(
+ flag(this, 'object') instanceof constructor
+ , 'expected #{this} to be an instance of ' + name
+ , 'expected #{this} 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) {
+ var obj = flag(this, 'object')
+ , value = util.getPathValue(name, obj)
+ , negate = flag(this, 'negate');
+
+ if (negate && undefined !== val) {
+ if (undefined === value) {
+ throw new Error(util.inspect(obj) + ' has no property ' + util.inspect(name));
+ }
+ } else {
+ this.assert(
+ undefined !== value
+ , 'expected #{this} to have a property ' + util.inspect(name)
+ , 'expected #{this} to not have property ' + util.inspect(name));
+ }
+
+ if (undefined !== val) {
+ this.assert(
+ val === value
+ , 'expected #{this} to have a property ' + util.inspect(name) + ' of #{exp}, but got #{act}'
+ , 'expected #{this} to not have a property ' + util.inspect(name) + ' of #{act}'
+ , val
+ , value
+ );
+ }
+
+ flag(this, 'object', value);
+ 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) {
+ var obj = flag(this, 'object');
+ this.assert(
+ obj.hasOwnProperty(name)
+ , 'expected #{this} to have own property ' + util.inspect(name)
+ , 'expected #{this} to not have own property ' + util.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) {
+ var obj = flag(this, 'object');
+ new Assertion(obj).to.have.property('length');
+ var len = obj.length;
+
+ this.assert(
+ len == n
+ , 'expected #{this} to have a length of #{exp} but got #{act}'
+ , 'expected #{this} to not have a length of #{act}'
+ , n
+ , 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) {
+ var obj = flag(this, 'object');
+ this.assert(
+ re.exec(obj)
+ , 'expected #{this} to match ' + re
+ , 'expected #{this} not to match ' + re);
+
+ return this;
+};
+
+
+/**
+ * # .string(string)
+ *
+ * Assert inclusion of string in string.
+ *
+ * expect('foobar').to.have.string('bar');
+ *
+ * @name string
+ * @param {String} string
+ * @api public
+ */
+
+Assertion.prototype.string = function (str) {
+ var obj = flag(this, 'object');
+ new Assertion(obj).is.a('string');
+
+ this.assert(
+ ~obj.indexOf(str)
+ , 'expected #{this} to contain ' + util.inspect(str)
+ , 'expected #{this} to not contain ' + util.inspect(str));
+
+ return this;
+};
+
+/**
+ * # .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 obj = flag(this, 'object')
+ , 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(obj)
+ , len = keys.length;
+
+ // Inclusion
+ ok = keys.every(function(key){
+ return ~actual.indexOf(key);
+ });
+
+ // Strict
+ if (!flag(this, 'negate') && !flag(this, 'contains')) {
+ ok = ok && keys.length == actual.length;
+ }
+
+ // Key string
+ if (len > 1) {
+ keys = keys.map(function(key){
+ return util.inspect(key);
+ });
+ var last = keys.pop();
+ str = keys.join(', ') + ', and ' + last;
+ } else {
+ str = util.inspect(keys[0]);
+ }
+
+ // Form
+ str = (len > 1 ? 'keys ' : 'key ') + str;
+
+ // Have / include
+ str = (flag(this, 'contains') ? 'contain ' : 'have ') + str;
+
+ // Assertion
+ this.assert(
+ ok
+ , 'expected #{this} to ' + str
+ , 'expected #{this} to not ' + str
+ , keys
+ , Object.keys(obj)
+ );
+
+ return this;
+}
+
+/**
+ * # .throw(constructor)
+ *
+ * Assert that a function will throw a specific type of error, or specific type of error
+ * (as determined using `instanceof`), optionally with a RegExp or string inclusion test
+ * for the error's message.
+ *
+ * var err = new ReferenceError('This is a bad function.');
+ * var fn = function () { throw err; }
+ * expect(fn).to.throw(ReferenceError);
+ * expect(fn).to.throw(Error);
+ * expect(fn).to.throw(/bad function/);
+ * expect(fn).to.not.throw('good function');
+ * expect(fn).to.throw(ReferenceError, /bad function/);
+ * expect(fn).to.throw(err);
+ * expect(fn).to.not.throw(new RangeError('Out of range.'));
+ *
+ * Please note that when a throw expectation is negated, it will check each
+ * parameter independently, starting with error constructor type. The appropriate way
+ * to check for the existence of a type of error but for a message that does not match
+ * is to use `and`.
+ *
+ * expect(fn).to.throw(ReferenceError).and.not.throw(/good function/);
+ *
+ * @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, msg) {
+ var obj = flag(this, 'object');
+ new Assertion(obj).is.a('function');
+
+ var thrown = false
+ , desiredError = null
+ , name = null;
+
+ if (arguments.length === 0) {
+ msg = null;
+ constructor = null;
+ } else if (constructor && (constructor instanceof RegExp || 'string' === typeof constructor)) {
+ msg = constructor;
+ constructor = null;
+ } else if (constructor && constructor instanceof Error) {
+ desiredError = constructor;
+ constructor = null;
+ msg = null;
+ } else if (typeof constructor === 'function') {
+ name = (new constructor()).name;
+ } else {
+ constructor = null;
+ }
+
+ try {
+ obj();
+ } catch (err) {
+ // first, check desired error
+ if (desiredError) {
+ this.assert(
+ err === desiredError
+ , 'expected #{this} to throw ' + util.inspect(desiredError) + ' but ' + util.inspect(err) + ' was thrown'
+ , 'expected #{this} to not throw ' + util.inspect(desiredError)
+ );
+ return this;
+ }
+ // next, check constructor
+ if (constructor) {
+ this.assert(
+ err instanceof constructor
+ , 'expected #{this} to throw ' + name + ' but a ' + err.name + ' was thrown'
+ , 'expected #{this} to not throw ' + name );
+ if (!msg) return this;
+ }
+ // next, check message
+ if (err.message && msg && msg instanceof RegExp) {
+ this.assert(
+ msg.exec(err.message)
+ , 'expected #{this} to throw error matching ' + msg + ' but got ' + util.inspect(err.message)
+ , 'expected #{this} to throw error not matching ' + msg
+ );
+ return this;
+ } else if (err.message && msg && 'string' === typeof msg) {
+ this.assert(
+ ~err.message.indexOf(msg)
+ , 'expected #{this} to throw error including #{exp} but got #{act}'
+ , 'expected #{this} to throw error not including #{act}'
+ , msg
+ , err.message
+ );
+ return this;
+ } else {
+ thrown = true;
+ }
+ }
+
+ var expectedThrown = name ? name : desiredError ? util.inspect(desiredError) : 'an error';
+
+ this.assert(
+ thrown === true
+ , 'expected #{this} to throw ' + expectedThrown
+ , 'expected #{this} to not throw ' + expectedThrown);
+
+ return this;
+};
+
+/**
+ * # .respondTo(method)
+ *
+ * Assert that object/class will respond to a method.
+ *
+ * expect(Klass).to.respondTo('bar');
+ * expect(obj).to.respondTo('bar');
+ *
+ * @name respondTo
+ * @param {String} method
+ * @api public
+ */
+
+Assertion.prototype.respondTo = function (method) {
+ var obj = flag(this, 'object')
+ , context = ('function' === typeof obj)
+ ? obj.prototype[method]
+ : obj[method];
+
+ this.assert(
+ 'function' === typeof context
+ , 'expected #{this} to respond to ' + util.inspect(method)
+ , 'expected #{this} to not respond to ' + util.inspect(method)
+ , 'function'
+ , typeof context
+ );
+
+ return this;
+};
+
+/**
+ * # .satisfy(method)
+ *
+ * Assert that passes a truth test.
+ *
+ * expect(1).to.satisfy(function(num) { return num > 0; });
+ *
+ * @name satisfy
+ * @param {Function} matcher
+ * @api public
+ */
+
+Assertion.prototype.satisfy = function (matcher) {
+ var obj = flag(this, 'object');
+ this.assert(
+ matcher(obj)
+ , 'expected #{this} to satisfy ' + util.inspect(matcher)
+ , 'expected #{this} to not satisfy' + util.inspect(matcher)
+ , this.negate ? false : true
+ , matcher(obj)
+ );
+
+ return this;
+};
+
+/**
+ * # .closeTo(expected, delta)
+ *
+ * Assert that actual is equal to +/- delta.
+ *
+ * expect(1.5).to.be.closeTo(1, 0.5);
+ *
+ * @name closeTo
+ * @param {Number} expected
+ * @param {Number} delta
+ * @api public
+ */
+
+Assertion.prototype.closeTo = function (expected, delta) {
+ var obj = flag(this, 'object');
+ this.assert(
+ (obj - delta === expected) || (obj + delta === expected)
+ , 'expected #{this} to be close to ' + expected + ' +/- ' + delta
+ , 'expected #{this} not to be close to ' + expected + ' +/- ' + delta);
+
+ return this;
+};
+
+/*!
+ * Aliases.
+ */
+
+(function alias(name, as){
+ Assertion.prototype[as] = Assertion.prototype[name];
+ return alias;
+})
+('equal', 'eq')
+('above', 'mt')
+('below', 'lt')
+('length', 'lengthOf')
+('keys', 'key')
+('ownProperty', 'haveOwnProperty')
+('above', 'greaterThan')
+('below', 'lessThan')
+('Throw', 'throws')
+('Throw', 'throw')
+('instanceOf', 'instanceof');
+
+}); // module: assertion.js
+
+require.register("browser/error.js", function(module, exports, require){
+/*!
+ * chai
+ * Copyright(c) 2011-2012 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+module.exports = AssertionError;
+
+function AssertionError (options) {
+ options = options || {};
+ this.message = options.message;
+ this.actual = options.actual;
+ this.expected = options.expected;
+ this.operator = options.operator;
+
+ if (options.stackStartFunction && Error.captureStackTrace) {
+ var stackStartFunction = options.stackStartFunction;
+ Error.captureStackTrace(this, stackStartFunction);
+ }
+}
+
+AssertionError.prototype = Object.create(Error.prototype);
+AssertionError.prototype.name = 'AssertionError';
+AssertionError.prototype.constructor = AssertionError;
+
+AssertionError.prototype.toString = function() {
+ return this.message;
+};
+
+}); // module: browser/error.js
+
+require.register("chai.js", function(module, exports, require){
+/*!
+ * chai
+ * Copyright(c) 2011-2012 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+var used = []
+ , exports = module.exports = {};
+
+/*!
+ * Chai version
+ */
+
+exports.version = '1.0.0-rc1';
+
+/*!
+ * Primary `Assertion` prototype
+ */
+
+exports.Assertion = require('./assertion');
+
+/*!
+ * Assertion Error
+ */
+
+exports.AssertionError = require('./browser/error');
+
+/*!
+ * Utils for plugins (not exported)
+ */
+
+var util = require('./utils');
+
+/**
+ * # .use(function)
+ *
+ * Provides a way to extend the internals of Chai
+ *
+ * @param {Function}
+ * @returns {this} for chaining
+ * @api public
+ */
+
+exports.use = function (fn) {
+ if (!~used.indexOf(fn)) {
+ fn(this, util);
+ used.push(fn);
+ }
+
+ return this;
+};
+
+/*!
+ * Expect interface
+ */
+
+var expect = require('./interface/expect');
+exports.use(expect);
+
+/*!
+ * Should interface
+ */
+
+var should = require('./interface/should');
+exports.use(should);
+
+/*!
+ * Assert interface
+ */
+
+var assert = require('./interface/assert');
+exports.use(assert);
+
+}); // module: chai.js
+
+require.register("interface/assert.js", function(module, exports, require){
+/*!
+ * chai
+ * Copyright(c) 2011-2012 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');
+ *
+ * #### Configuration
+ *
+ * By default, Chai does not show stack traces upon an AssertionError. This can
+ * be changed by modifying the `includeStack` parameter for chai.Assertion. For example:
+ *
+ * var chai = require('chai');
+ * chai.Assertion.includeStack = true; // defaults to false
+ */
+
+module.exports = function (chai, util) {
+
+ /*!
+ * Chai dependencies.
+ */
+
+ var Assertion = chai.Assertion
+ , flag = util.flag;
+
+ /*!
+ * Module export.
+ */
+
+ var assert = chai.assert = {};
+
+ /**
+ * # .fail(actual, expect, msg, operator)
+ *
+ * Throw a failure. Node.js compatible.
+ *
+ * @name fail
+ * @param {*} actual value
+ * @param {*} expected value
+ * @param {String} message
+ * @param {String} operator
+ * @api public
+ */
+
+ assert.fail = function (actual, expected, message, operator) {
+ throw new chai.AssertionError({
+ actual: actual
+ , expected: expected
+ , message: message
+ , operator: operator
+ , stackStartFunction: assert.fail
+ });
+ }
+
+ /**
+ * # .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 == flag(test, 'object')
+ , 'expected #{this} to equal #{exp}'
+ , 'expected #{this} to not equal #{act}'
+ , exp
+ , act
+ );
+ };
+
+ /**
+ * # .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 != flag(test, 'object')
+ , 'expected #{this} to not equal #{exp}'
+ , 'expected #{this} to equal #{act}'
+ , exp
+ , act
+ );
+ };
+
+ /**
+ * # .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.equal(null);
+ };
+
+ /**
+ * # .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.not.equal(null);
+ };
+
+ /**
+ * # .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);
+ };
+
+ /**
+ * # .isDefined(value, [message])
+ *
+ * Assert `value` is not undefined.
+ *
+ * var tea = 'cup of chai';
+ * assert.isDefined(tea, 'no tea defined');
+ *
+ * @name isUndefined
+ * @param {*} value
+ * @param {String} message
+ * @api public
+ */
+
+ assert.isDefined = function (val, msg) {
+ new Assertion(val, msg).to.not.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');
+ };
+
+ /**
+ * # .isNotFunction(value, [message])
+ *
+ * Assert `value` is NOT a function.
+ *
+ * var serve_tea = [ 'heat', 'pour', 'sip' ];
+ * assert.isNotFunction(serve_tea, 'great, we can have tea now');
+ *
+ * @name isNotFunction
+ * @param {Mixed} value
+ * @param {String} message
+ * @api public
+ */
+
+ assert.isNotFunction = function (val, msg) {
+ new Assertion(val, msg).to.not.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');
+ };
+
+ /**
+ * # .isNotObject(value, [message])
+ *
+ * Assert `value` is NOT an object.
+ *
+ * var selection = 'chai'
+ * assert.isObject(selection, 'tea selection is not an object');
+ *
+ * @name isNotObject
+ * @param {Mixed} value
+ * @param {String} message
+ * @api public
+ */
+
+ assert.isNotObject = function (val, msg) {
+ new Assertion(val, msg).to.not.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 {Mixed} value
+ * @param {String} message
+ * @api public
+ */
+
+ assert.isArray = function (val, msg) {
+ new Assertion(val, msg).to.be.instanceOf(Array);
+ };
+
+ /**
+ * # .isArray(value, [message])
+ *
+ * Assert `value` is NOT an instance of Array.
+ *
+ * var menu = 'green|chai|oolong';
+ * assert.isNotArray(menu, 'what kind of tea do we want?');
+ *
+ * @name isNotArray
+ * @param {Mixed} value
+ * @param {String} message
+ * @api public
+ */
+
+ assert.isNotArray = function (val, msg) {
+ new Assertion(val, msg).to.not.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');
+ };
+
+ /**
+ * # .isNotString(value, [message])
+ *
+ * Assert `value` is NOT a string.
+ *
+ * var teaorder = 4;
+ * assert.isNotString(tea_order, 'order placed');
+ *
+ * @name isNotString
+ * @param {Mixed} value
+ * @param {String} message
+ * @api public
+ */
+
+ assert.isNotString = function (val, msg) {
+ new Assertion(val, msg).to.not.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.a('number');
+ };
+
+ /**
+ * # .isNotNumber(value, [message])
+ *
+ * Assert `value` NOT is a number
+ *
+ * var cups = '2 cups please';
+ * assert.isNotNumber(cups, 'how many cups');
+ *
+ * @name isNotNumber
+ * @param {Mixed} value
+ * @param {String} message
+ * @api public
+ */
+
+ assert.isNotNumber = function (val, msg) {
+ new Assertion(val, msg).to.not.be.a('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 {Mixed} value
+ * @param {String} message
+ * @api public
+ */
+
+ assert.isBoolean = function (val, msg) {
+ new Assertion(val, msg).to.be.a('boolean');
+ };
+
+ /**
+ * # .isNotBoolean(value, [message])
+ *
+ * Assert `value` is NOT a boolean
+ *
+ * var teaready = 'yep'
+ * , teaserved = 'nope';
+ *
+ * assert.isNotBoolean(tea_ready, 'is the tea ready');
+ * assert.isNotBoolean(tea_served, 'has tea been served');
+ *
+ * @name isNotBoolean
+ * @param {Mixed} value
+ * @param {String} message
+ * @api public
+ */
+
+ assert.isNotBoolean = function (val, msg) {
+ new Assertion(val, msg).to.not.be.a('boolean');
+ };
+
+ /**
+ * # .typeOf(value, name, [message])
+ *
+ * Assert typeof `value` is `name`.
+ *
+ * assert.typeOf('tea', 'string', 'we have a string');
+ *
+ * @name typeOf
+ * @param {Mixed} value
+ * @param {String} typeof name
+ * @param {String} message
+ * @api public
+ */
+
+ assert.typeOf = function (val, type, msg) {
+ new Assertion(val, msg).to.be.a(type);
+ };
+
+ /**
+ * # .notTypeOf(value, name, [message])
+ *
+ * Assert typeof `value` is NOT `name`.
+ *
+ * assert.notTypeOf('tea', 'string', 'we have a string');
+ *
+ * @name notTypeOf
+ * @param {Mixed} value
+ * @param {String} typeof name
+ * @param {String} message
+ * @api public
+ */
+
+ assert.notTypeOf = function (val, type, msg) {
+ new Assertion(val, msg).to.not.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);
+ };
+
+ /**
+ * # .notInstanceOf(object, constructor, [message])
+ *
+ * Assert `value` is NOT instanceof `constructor`.
+ *
+ * var Tea = function (name) { this.name = name; }
+ * , Chai = new String('chai');
+ *
+ * assert.notInstanceOf(Chai, Tea, 'chai is an instance of tea');
+ *
+ * @name notInstanceOf
+ * @param {Object} object
+ * @param {Constructor} constructor
+ * @param {String} message
+ * @api public
+ */
+
+ assert.notInstanceOf = function (val, type, msg) {
+ new Assertion(val, msg).to.not.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);
+ };
+
+ /**
+ * # .notMatch(value, regex, [message])
+ *
+ * Assert that `value` does not match regular expression.
+ *
+ * assert.notMatch('foobar', /^foo/, 'Regexp matches');
+ *
+ * @name notMatch
+ * @param {*} value
+ * @param {RegExp} RegularExpression
+ * @param {String} message
+ * @api public
+ */
+
+ assert.notMatch = function (exp, re, msg) {
+ new Assertion(exp, msg).to.not.match(re);
+ };
+
+ /**
+ * # .ownProperty(object, property, [message])
+ *
+ * Assert that `object` has property. Can use dot-notation for deep reference.
+ *
+ * assert.ownProperty({ tea: { green: 'matcha' }}, 'tea.green');
+ *
+ * @name ownProperty
+ * @param {Object} object
+ * @param {String} Property address
+ * @param {String} message
+ * @api public
+ */
+
+ assert.ownProperty = function (obj, prop, msg) {
+ new Assertion(obj, msg).to.have.property(prop);
+ };
+
+ /**
+ * # .notOwnProperty(object, property, [message])
+ *
+ * Assert that `object` does not have property. Can use dot-notation for deep reference.
+ *
+ * assert.ownProperty({ tea: { green: 'matcha' }}, 'tea.oolong');
+ *
+ * @name notOwnProperty
+ * @param {Object} object
+ * @param {String} property address
+ * @param {String} message
+ * @api public
+ */
+
+ assert.notOwnProperty = function (obj, prop, msg) {
+ new Assertion(obj, msg).to.not.have.property(prop);
+ };
+
+ /**
+ * # .ownPropertyVal(object, property, value, [message])
+ *
+ * Assert that `object` has property with `value`.
+ * Can use dot-notation for deep reference.
+ *
+ * assert.ownPropertyVal({ tea: { green: 'matcha' }}, 'tea.green', 'matcha');
+ *
+ * @name ownPropertyVal
+ * @param {Object} object
+ * @param {String} property address
+ * @param {Mixed} value
+ * @param {String} message
+ * @api public
+ */
+
+ assert.ownPropertyVal = function (obj, prop, val, msg) {
+ new Assertion(obj, msg).to.have.property(prop)
+ .and.equal(val);
+ };
+
+ /**
+ * # .ownPropertyNotVal(object, property, value, [message])
+ *
+ * Assert that `object` has property but `value`
+ * does not equal `value`. Can use dot-notation for deep reference.
+ *
+ * assert.ownPropertyNotVal({ tea: { green: 'matcha' }}, 'tea.green', 'konacha');
+ *
+ * @name ownPropertyNotVal
+ * @param {Object} object
+ * @param {String} property address
+ * @param {Mixed} value
+ * @param {String} message
+ * @api public
+ */
+ assert.ownPropertyNotVal = function (obj, prop, val, msg) {
+ new Assertion(obj, msg).to.have.property(prop)
+ .and.not.equal(val);
+ };
+
+ /**
+ * # .length(object, length, [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);
+ };
+
+ /**
+ * # .operator(val, operator, val2, [message])
+ *
+ * Compare two values using operator.
+ *
+ * assert.operator(1, '<', 2, 'everything is ok');
+ * assert.operator(1, '>', 2, 'this will fail');
+ *
+ * @name operator
+ * @param {*} object to test
+ * @param {String} operator
+ * @param {*} second object
+ * @param {String} message
+ * @api public
+ */
+
+ assert.operator = function (val, operator, val2, msg) {
+ if (!~['==', '===', '>', '>=', '<', '<=', '!=', '!=='].indexOf(operator)) {
+ throw new Error('Invalid operator "' + operator + '"');
+ }
+ var test = new Assertion(eval(val + operator + val2), msg);
+ test.assert(
+ true === flag(test, 'object')
+ , 'expected ' + util.inspect(val) + ' to be ' + operator + ' ' + util.inspect(val2)
+ , 'expected ' + util.inspect(val) + ' to not be ' + operator + ' ' + util.inspect(val2) );
+ };
+
+ /*!
+ * 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-2012 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+module.exports = function (chai, util) {
+ 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-2012 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+module.exports = function (chai, util) {
+ var Assertion = chai.Assertion;
+
+ function loadShould () {
+ // 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, errt, errs) {
+ new Assertion(fn).to.Throw(errt, errs);
+ };
+
+ 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, errt, errs) {
+ new Assertion(fn).to.not.Throw(errt, errs);
+ };
+
+ should.not.exist = function (val) {
+ new Assertion(val).to.not.exist;
+ }
+
+ should['throw'] = should['Throw'];
+ should.not['throw'] = should.not['Throw'];
+
+ return should;
+ };
+
+ chai.should = loadShould;
+ chai.Should = loadShould;
+};
+
+}); // module: interface/should.js
+
+require.register("utils/addMethod.js", function(module, exports, require){
+/*!
+ * Chai - addMethod utility
+ * Copyright(c) 2012 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+/**
+ * # addMethod (ctx, name, method)
+ *
+ * Adds a method to the prototype of an object.
+ *
+ * utils.addMethod(chai.Assertion, 'foo', function (str) {
+ * var obj = utils.flag(this, 'object');
+ * new chai.Assertion(obj).to.be.equal(str);
+ * return this;
+ * });
+ *
+ * Then can be used as any other assertion.
+ *
+ * expect(fooStr).to.be.foo('bar');
+ *
+ * @param {Function|Object} context chai.Assertion || chai.Assertion.prototype
+ * @param {String} name of method to add
+ * @param {Function} method function to used for name
+ * @api public
+ */
+
+module.exports = function (ctx, name, method) {
+ var context = ('function' === typeof ctx) ? ctx.prototype : ctx;
+ context[name] = function () {
+ method.apply(this, arguments);
+ return this;
+ };
+};
+
+}); // module: utils/addMethod.js
+
+require.register("utils/addProperty.js", function(module, exports, require){
+/*!
+ * Chai - addProperty utility
+ * Copyright(c) 2012 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+/**
+ * # addProperty (ctx, name, getter)
+ *
+ * Adds a property to the prototype of an object.
+ *
+ * utils.addProperty(chai.Assertion, 'foo', function () {
+ * var obj = utils.flag(this, 'object');
+ * new chai.Assertion(obj).to.be.instanceof(Foo);
+ * return this;
+ * });
+ *
+ * Then can be used as any other assertion:
+ *
+ * expect(myFoo).to.be.foo;
+ *
+ * @param {Function|Object} context chai.Assertion || chai.Assertion.prototype
+ * @param {String} name of property to add
+ * @param {Function} getter function to used for name
+ * @api public
+ */
+
+module.exports = function (ctx, name, getter) {
+ var context = ('function' === typeof ctx) ? ctx.prototype : ctx;
+ Object.defineProperty(context, name,
+ { get: function () {
+ getter.call(this);
+ return this;
+ }
+ , configurable: true
+ });
+};
+
+}); // module: utils/addProperty.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/flag.js", function(module, exports, require){
+/*!
+ * Chai - flag utility
+ * Copyright(c) 2012 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+/**
+ * # flag(object ,key, [value])
+ *
+ * Get or set a flag value on an object. If a
+ * value is provided it will be set, else it will
+ * return the currently set value or `undefined` if
+ * the value is not set.
+ *
+ * @param {Object} object (constructed Assertion
+ * @param {String} key
+ * @param {Mixed} value (optional)
+ * @api private
+ */
+
+module.exports = function (obj, key, value) {
+ var flags = obj.__flags || (obj.__flags = Object.create(null));
+ if (arguments.length === 3) {
+ flags[key] = value;
+ } else {
+ return flags[key];
+ }
+};
+
+}); // module: utils/flag.js
+
+require.register("utils/getActual.js", function(module, exports, require){
+/*!
+ * Chai - getActual utility
+ * Copyright(c) 2012 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+/**
+ * # getActual(object, [actual])
+ *
+ * Returns the `actual` value for an Assertion
+ *
+ * @param {Object} object (constructed Assertion)
+ * @param {Arguments} chai.Assertion.prototype.assert arguments
+ */
+
+module.exports = function (obj, args) {
+ var actual = args[4];
+ return 'undefined' !== actual ? actual : obj.obj;
+};
+
+}); // module: utils/getActual.js
+
+require.register("utils/getMessage.js", function(module, exports, require){
+/*!
+ * Chai - message composition utility
+ * Copyright(c) 2012 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+/*!
+ * Module dependancies
+ */
+
+var flag = require('./flag')
+ , getActual = require('./getActual')
+ , inspect = require('./inspect');
+
+/**
+ * # getMessage(object, message, negateMessage)
+ *
+ * Construct the error message based on flags
+ * and template tags. Template tags will return
+ * a stringified inspection of the object referenced.
+ *
+ * Messsage template tags:
+ * - `#{this}` current asserted object
+ * - `#{act}` actual value
+ * - `#{exp}` expected value
+ *
+ * @param {Object} object (constructed Assertion)
+ * @param {Arguments} chai.Assertion.prototype.assert arguments
+ */
+
+module.exports = function (obj, args) {
+ var negate = flag(obj, 'negate')
+ , val = flag(obj, 'object')
+ , expected = args[3]
+ , actual = getActual(obj, args)
+ , msg = negate ? args[2] : args[1];
+
+ msg = msg
+ .replace(/#{this}/g, inspect(val))
+ .replace(/#{act}/g, inspect(actual))
+ .replace(/#{exp}/g, inspect(expected));
+
+ return obj.msg ? obj.msg + ': ' + msg : msg;
+};
+
+}); // module: utils/getMessage.js
+
+require.register("utils/getName.js", function(module, exports, require){
+/*!
+ * Chai - getName utility
+ * Copyright(c) 2012 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+/**
+ * # getName(func)
+ *
+ * Gets the name of a function, in a cross-browser way.