konacha-chai-matchers 0.0.1

data/vendor/assets/javascripts/chai-stats.js

@@ -0,0 +1,286 @@
+!function (name, definition) {
+  if (typeof define == 'function' && typeof define.amd  == 'object') define(definition);
+  else this[name] = definition();
+}('chai_stats', 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("calc", function (module, exports, require) {
+/*!
+ * Chai Stats - calculation utilities
+ * Copyright (c) 2012 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licenced
+ */
+
+/**
+ * # sum
+ *
+ * Returns the sum of a given array of numbers.
+ *
+ * @param {Array} numbers to sum
+ * @returns sum
+ */
+
+exports.sum = function (nums) {
+  var res = 0;
+  for (var i = 0; i < nums.length; i++)
+    res += nums[i];
+  return res;
+};
+
+/**
+ * # mean
+ *
+ * Returns the mean (average) of a given array of numbers.
+ *
+ * @param {Array} numbers to average
+ * @returs mean
+ */
+
+exports.mean = function (nums) {
+  var sum = exports.sum(nums);
+  return sum / nums.length;
+};
+
+/**
+ * # sdeviation
+ *
+ * Returns the standard deviation of a given array of numbers.
+ *
+ * @param {Array} numbers for stdev
+ * @return standard deviation
+ */
+
+exports.sdeviation = function (nums) {
+  var devs = []
+    , mean = exports.mean(nums);
+  for (var i = 0; i < nums.length; i++)
+    devs.push(nums[i] - mean);
+  for (var d = 0; d < devs.length; d++)
+    devs[d] = Math.pow(devs[d], 2);
+  var davg = exports.sum(devs) / (devs.length - 1);
+  return Math.sqrt(davg);
+};
+
+}); // module calc
+
+
+require.register("stats", function (module, exports, require) {
+var calc = require('./calc');
+
+module.exports = function (chai, _) {
+  var Assertion = chai.Assertion
+    , flag = _.flag
+
+  Assertion.addProperty('almost', function () {
+    flag(this, 'almost', true);
+  });
+
+  /**
+   * # .almost.equal(expected, [precision])
+   *
+   * The same as NumPy's assert_almost_equal, for scalars.
+   * Assert near equality: abs(expected-actual) < 0.5 * 10**(-decimal)
+   *
+   *      expect(3.1415).to.almost.equal(3.14159, 3);
+   *      assert.almostEqual(3.1416, 3.14159, 3, 'these numbers are almost equal');
+   *
+   * @name equal
+   * @param {Number} actual
+   * @param {Number} expected
+   * @param {Number} decimal
+   * @param {String} message
+   * @api public
+   */
+
+  Assertion.overwriteMethod('equal', function(_super) {
+    return function equal (exp, precision) {
+      if (flag(this, 'almost')) {
+        var act = flag(this, 'object')
+        if (null == precision) precision = 7;
+        this.assert(
+            Math.abs(act - exp) < 0.5 * Math.pow(10, -precision)
+          , "expected #{this} to equal #{exp} up to " + _.inspect(precision) + " decimal places"
+          , "expected #{this} to not equal #{exp} up to " + _.inspect(precision) + " decimal places"
+          , exp
+          , act
+        );
+      } else {
+        _super.apply(this, arguments);
+      }
+    };
+  });
+
+  _.addMethod(chai.assert, 'almostEqual', function (act, exp, precision, msg) {
+    new Assertion(act, msg).to.almost.equal(exp, precision);
+  });
+
+  /**
+   * # .deepAlmostEqual(actual, expected, [decimal, message])
+   *
+   * The same as NumPy's assert_almost_equal, for objects whose leaves are all numbers.
+   * Assert near equality: abs(expected-actual) < 0.5 * 10**(-decimal) for every leaf.
+   *
+   *      assert.deepAlmostEqual({pi: 3.1416}, {pi: 3.14159}, 3);
+   *
+   * @name equal
+   * @param {*} actual
+   * @param {*} expected
+   * @param {Number} decimal
+   * @param {String} message
+   * @api public
+   */
+
+  Assertion.overwriteMethod('eql', function (_super) {
+    return function eql (exp, precision) {
+      if (flag(this, 'almost')) {
+        if (null == precision) precision = 7;
+        var act = flag(this, 'object')
+          , tol = 0.5 * Math.pow(10, -precision);
+
+        function deepEql (act, exp) {
+          if (Object(act) === act){
+            for (var k in act) {
+              if (!(deepEql(act[k], exp[k]))) {
+                return false;
+              }
+            }
+            return true;
+          } else {
+            return Math.abs(act - exp) < tol;
+          }
+        };
+
+        this.assert(
+            deepEql(act, exp)
+          , "expected #{this} to equal #{exp} up to " + _.inspect(precision) + ' decimal places'
+          , "expected #{this} to not equal #{exp} up to " + _.inspect(precision) + ' decimal places'
+          , exp
+          , act
+        );
+      } else {
+        _super.apply(this, arguments);
+      }
+    };
+  });
+
+  _.addMethod(chai.assert, 'deepAlmostEqual', function (act, exp, precision, msg) {
+    new Assertion(act, msg).to.almost.eql(exp, precision);
+  });
+
+  /**
+   * ### .sum
+   *
+   * Modifies the assertion subject with the sum of an
+   * array of number so it can be compared using chai's
+   * core assertions.
+   *
+   *     expect([ 1, 2, 3 ]).to.have.sum.equal(6);
+   *     expect([ 1, 2, 3 ]).to.have.sum.above(5);
+   *     expect([ 1, 2, 3 ]).to.have.sum.below(7);
+   *
+   * @name sum
+   * @expects {Array}
+   * @api public
+   */
+
+  Assertion.addProperty('sum', function () {
+    var obj = flag(this, 'object');
+    new Assertion(obj).to.be.instanceOf(Array);
+    flag(this, 'object', calc.sum(obj));
+  });
+
+  /**
+   * ### .mean
+   *
+   * Modifies the assertion subject with the mean of an
+   * array of number so it can be compared using chai's
+   * core assertions.
+   *
+   *     expect([ 1, 2, 3 ]).to.have.mean.equal(2);
+   *     expect([ 1, 2, 3 ]).to.have.mean.above(1.5);
+   *     expect([ 1, 2, 3 ]).to.have.mean.below(2.5);
+   *
+   * @name mean
+   * @expects {Array}
+   * @api public
+   */
+
+  Assertion.addProperty('mean', function () {
+    var obj = flag(this, 'object');
+    new Assertion(obj).to.be.instanceOf(Array);
+    flag(this, 'object', calc.mean(obj));
+  });
+
+  function deviation () {
+    var obj = flag(this, 'object');
+    new Assertion(obj).to.be.instanceOf(Array);
+    flag(this, 'object', calc.sdeviation(obj));
+  }
+
+  /**
+   * ### .deviation
+   *
+   * Modifies the assertion subject with the standard
+   * deviations of an array of number so it can be
+   * compared using chai's core assertions.
+   *
+   *     expect([ 1, 2, 3, 4 ]).to.have.deviation.almost.equal(1.290, 2);
+   *
+   * @name mean
+   * @expects {Array}
+   * @api public
+   */
+
+  Assertion.addProperty('stdev', deviation);
+  Assertion.addProperty('deviation', deviation);
+};
+
+}); // module stats
+  return require('stats');
+});
+
+chai.use(chai_stats);

data/vendor/assets/javascripts/chai-timers.js

@@ -0,0 +1,174 @@
+!function (context, definition) {
+  if (typeof require === "function" && typeof exports === "object" && typeof module === "object") {
+    module.exports = definition();
+  } else if (typeof define === 'function' && typeof define.amd  === 'object') {
+    define(definition);
+  } else {
+    if (!context.chai) throw new Error('Chai cannot be found in current scope.');
+    context.chai.use(definition());
+  }
+}(this, function () {
+
+
+  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.alias = function (from, to) {
+    var fn = require.modules[from];
+    require.modules[to] = fn;
+  };
+
+
+  require.register("chai-timers.js", function(module, exports, require){
+    var Timer = require('./timer');
+
+    module.exports = function (chai, _) {
+      var Assertion = chai.Assertion;
+
+      chai.Timer = Timer;
+
+      chai.timer = function (name) {
+        return new Timer(name);
+      };
+
+      Assertion.addProperty('timer', function () {
+        this.assert(
+            this._obj instanceof Timer
+          , 'expected #{this} to be a chai timer'
+          , 'expected #{this} to not be a chai timer' );
+      });
+
+      [ 'started', 'stopped', 'created' ].forEach(function (when) {
+        Assertion.overwriteProperty(when, function (_super) {
+          return function () {
+            if (this._obj instanceof Timer) {
+              _.flag(this, 'timer_when', when);
+            } else {
+              _super.call(this);
+            }
+          }
+        });
+      });
+
+      Assertion.overwriteMethod('before', function (_super) {
+        return function assertBefore (timer2, when2) {
+          var timer1 = this._obj;
+          new Assertion(timer1).to.be.a.timer;
+          new Assertion(timer2).to.be.a.timer;
+
+          var when1 = _.flag(this, 'timer_when') || 'started';
+          when2 = when2 || when1;
+          var time1 = timer1[when1].getTime()
+            , time2 = timer2[when2].getTime();
+
+          this.assert(
+              time1 < time2
+            , 'expected timer {' + timer1.name + '} to have been ' + when1 + ' before timer {' + timer2.name + '} was ' + when2
+            , 'expected timer {' + timer1.name + '} to not have been ' + when1 + ' before timer {' + timer2.name + '} was ' + when2
+          );
+        };
+      });
+
+      Assertion.overwriteMethod('after', function (_super) {
+        return function assertBefore (timer2, when2) {
+          var timer1 = this._obj;
+          new Assertion(timer1).to.be.a.timer;
+          new Assertion(timer2).to.be.a.timer;
+
+          var when1 = _.flag(this, 'timer_when') || 'started';
+          when2 = when2 || when1;
+          var time1 = timer1[when1].getTime()
+            , time2 = timer2[when2].getTime();
+
+          this.assert(
+              time1 > time2
+            , 'expected timer {' + timer1.name + '} to have been ' + when1 + ' after timer {' + timer2.name + '} was ' + when2
+            , 'expected timer {' + timer1.name + '} to not have been ' + when1 + ' after timer {' + timer2.name + '} was' + when2
+          );
+        };
+      });
+
+    };
+
+  }); // module: chai-timers.js
+
+  require.register("timer.js", function(module, exports, require){
+
+    module.exports = Timer;
+
+    function Timer (name) {
+      this.name = name || 'timer';
+      this.created = new Date();
+      this.marks = [];
+      this.started = null;
+      this.stopped = null;
+    };
+
+    Object.defineProperty(Timer.prototype, 'elapsed',
+      { get: function () {
+          var start = this.started.getTime()
+            , stop = this.stopped.getTime();
+          return stop - start;
+        }
+    });
+
+    Timer.prototype.start = function (date) {
+      this.started = date || new Date();
+      return this;
+    };
+
+    Timer.prototype.stop = function (date) {
+      this.stopped = date || new Date();
+    };
+
+    Timer.prototype.mark = function (date) {
+      this.marks.push(date || new Date());
+    };
+
+  }); // module: timer.js
+
+  require.alias("./chai-timers.js", "chai-timers");
+
+  return require('chai-timers');
+});