ende 0.5.0 → 0.5.1

data/components/chaijs/chai/1.9.1/test/utilities.js

@@ -0,0 +1,309 @@
+describe('utilities', function () {
+  var expect = chai.expect;
+
+  after(function() {
+    // Some clean-up so we can run tests in a --watch
+    delete chai.Assertion.prototype.eqqqual;
+    delete chai.Assertion.prototype.result;
+    delete chai.Assertion.prototype.doesnotexist;
+  });
+
+  it('_obj', function () {
+    var foo = 'bar'
+      , test = expect(foo);
+
+    expect(test).to.have.property('_obj', foo);
+
+    var bar = 'baz';
+    test._obj = bar;
+
+    expect(test).to.have.property('_obj', bar);
+    test.equal(bar);
+  });
+
+  it('transferFlags', function () {
+    var foo = 'bar'
+      , test = expect(foo).not;
+
+    chai.use(function (_chai, utils) {
+      var obj = {};
+      utils.transferFlags(test, obj);
+      expect(utils.flag(obj, 'object')).to.equal(foo);
+      expect(utils.flag(obj, 'negate')).to.equal(true);
+    });
+  });
+
+  it('transferFlags, includeAll = false', function () {
+    var foo = 'bar';
+
+    chai.use(function (_chai, utils) {
+      var obj = {};
+      var test = function() {};
+
+      var assertion = new chai.Assertion({}, "message", test);
+      var flag = {};
+      utils.flag(obj, 'flagMe', flag);
+      utils.flag(obj, 'negate', true);
+      utils.transferFlags(test, obj, false);
+
+      expect(utils.flag(obj, 'object')).to.equal(undefined);
+      expect(utils.flag(obj, 'message')).to.equal(undefined);
+      expect(utils.flag(obj, 'ssfi')).to.equal(undefined);
+      expect(utils.flag(obj, 'negate')).to.equal(true);
+      expect(utils.flag(obj, 'flagMe')).to.equal(flag);
+    });
+  });
+
+
+  it('getPathValue', function () {
+    var object = {
+        hello: 'universe'
+      , universe: {
+          hello: 'world'
+        }
+      , world: [ 'hello', 'universe' ]
+      , complex: [
+            { hello: 'universe' }
+          , { universe: 'world' }
+          , [ { hello: 'world' } ]
+        ]
+    }
+
+    var arr = [ [ true ] ];
+
+    chai.use(function (_chai, utils) {
+      var gpv = utils.getPathValue;
+      expect(gpv('hello', object)).to.equal('universe');
+      expect(gpv('universe.hello', object)).to.equal('world');
+      expect(gpv('world[1]', object)).to.equal('universe');
+      expect(gpv('complex[1].universe', object)).to.equal('world');
+      expect(gpv('complex[2][0].hello', object)).to.equal('world');
+      expect(gpv('[0][0]', arr)).to.be.true;
+    });
+  });
+
+  it('addMethod', function () {
+    chai.use(function(_chai, utils) {
+      expect(_chai.Assertion).to.not.respondTo('eqqqual');
+      _chai.Assertion.addMethod('eqqqual', function (str) {
+        var object = utils.flag(this, 'object');
+        new _chai.Assertion(object).to.be.eql(str);
+      });
+      expect(_chai.Assertion).to.respondTo('eqqqual');
+    });
+
+    expect('spec').to.eqqqual('spec');
+  });
+
+  it('addMethod returning result', function () {
+    chai.use(function(_chai, utils) {
+      _chai.Assertion.addMethod('result', function () {
+        return 'result';
+      })
+    });
+
+    expect(expect('foo').result()).to.equal('result');
+  });
+
+  it('overwriteMethod', function () {
+    chai.use(function (_chai, _) {
+      expect(_chai.Assertion).to.respondTo('eqqqual');
+      _chai.Assertion.overwriteMethod('eqqqual', function (_super) {
+        return function (str) {
+          var object = _.flag(this, 'object');
+          if (object == 'cucumber' && str == 'cuke') {
+            _.flag(this, 'cucumber', true);
+          } else {
+            _super.apply(this, arguments);
+          }
+        };
+      });
+
+    });
+
+    var vege = expect('cucumber').to.eqqqual('cucumber');
+    expect(vege.__flags).to.not.have.property('cucumber');
+    var cuke = expect('cucumber').to.eqqqual('cuke');
+    expect(cuke.__flags).to.have.property('cucumber');
+
+    chai.use(function (_chai, _) {
+      expect(_chai.Assertion).to.not.respondTo('doesnotexist');
+      _chai.Assertion.overwriteMethod('doesnotexist', function (_super) {
+        expect(_super).to.be.a('function');
+        return function () {
+          _.flag(this, 'doesnt', true);
+          _super.apply(this, arguments);
+        }
+      });
+    });
+
+    var dne = expect('something').to.doesnotexist();
+    expect(dne.__flags).to.have.property('doesnt');
+  });
+
+  it('overwriteMethod returning result', function () {
+    chai.use(function (_chai, _) {
+      _chai.Assertion.overwriteMethod('result', function (_super) {
+        return function () {
+          return 'result';
+        }
+      });
+    });
+
+    expect(expect('foo').result()).to.equal('result');
+  });
+
+  it('addProperty', function () {
+    chai.use(function (_chai, _) {
+      _chai.Assertion.addProperty('tea', function () {
+        _.flag(this, 'tea', 'chai');
+      });
+    });
+
+    var assert = expect('chai').to.be.tea;
+    expect(assert.__flags.tea).to.equal('chai');
+  });
+
+  it('addProperty returning result', function () {
+    chai.use(function(_chai, _) {
+      _chai.Assertion.addProperty('result', function () {
+        return 'result';
+      })
+    });
+
+    expect(expect('foo').result).to.equal('result');
+  });
+
+  it('overwriteProperty', function () {
+    chai.use(function (_chai, _) {
+      expect(new chai.Assertion()).to.have.property('tea');
+      _chai.Assertion.overwriteProperty('tea', function (_super) {
+        return function () {
+          var act = _.flag(this, 'object');
+          if (act === 'matcha') {
+            _.flag(this, 'tea', 'matcha');
+          } else {
+            _super.call(this);
+          }
+        }
+      });
+    });
+
+    var matcha = expect('matcha').to.be.tea;
+    expect(matcha.__flags.tea).to.equal('matcha');
+    var assert = expect('something').to.be.tea;
+    expect(assert.__flags.tea).to.equal('chai');
+  });
+
+  it('overwriteProperty returning result', function () {
+    chai.use(function(_chai, _) {
+      _chai.Assertion.overwriteProperty('result', function (_super) {
+        return function () {
+          return 'result';
+        }
+      });
+    });
+
+    expect(expect('foo').result).to.equal('result');
+  });
+
+  it('getMessage', function () {
+    chai.use(function (_chai, _) {
+      expect(_.getMessage({}, [])).to.equal('');
+      expect(_.getMessage({}, [null, null, null])).to.equal('');
+
+      var obj = {};
+      _.flag(obj, 'message', 'foo');
+      expect(_.getMessage(obj, [])).to.contain('foo');
+    });
+  });
+
+  it('inspect with custom object-returning inspect()s', function () {
+    chai.use(function (_chai, _) {
+      var obj = {
+        outer: {
+          inspect: function () {
+            return { foo: 'bar' };
+          }
+        }
+      };
+
+      expect(_.inspect(obj)).to.equal('{ outer: { foo: \'bar\' } }');
+    });
+  });
+
+  it('addChainableMethod', function () {
+    chai.use(function (_chai, _) {
+      _chai.Assertion.addChainableMethod('x',
+        function () {
+          new chai.Assertion(this._obj).to.be.equal('x');
+        }
+      , function () {
+          this._obj = this._obj || {};
+          this._obj.__x = 'X!'
+        }
+      );
+
+      expect("foo").x.to.equal("foo");
+      expect("x").x();
+
+      expect(function () {
+        expect("foo").x();
+      }).to.throw(_chai.AssertionError);
+
+      // Verify whether the original Function properties are present.
+      // see https://github.com/chaijs/chai/commit/514dd6ce4#commitcomment-2593383
+      var propertyDescriptor = Object.getOwnPropertyDescriptor(chai.Assertion.prototype, "x");
+      expect(propertyDescriptor.get).to.have.property("call", Function.prototype.call);
+      expect(propertyDescriptor.get).to.have.property("apply", Function.prototype.apply);
+      expect(propertyDescriptor.get()).to.have.property("call", Function.prototype.call);
+      expect(propertyDescriptor.get()).to.have.property("apply", Function.prototype.apply);
+
+      var obj = {};
+      expect(obj).x.to.be.ok;
+      expect(obj).to.have.property('__x', 'X!');
+    })
+  });
+
+  it('overwriteChainableMethod', function () {
+    chai.use(function (_chai, _) {
+      _chai.Assertion.overwriteChainableMethod('x',
+        function(_super) {
+          return function() {
+            if (_.flag(this, 'marked')) {
+              new chai.Assertion(this._obj).to.be.equal('spot');
+            } else {
+              _super.apply(this, arguments);
+            }
+          };
+        }
+      , function(_super) {
+          return function() {
+            _.flag(this, 'message', 'x marks the spot');
+            _super.apply(this, arguments);
+          };
+        }
+      );
+
+      // Make sure the original behavior of 'x' remains the same
+      expect('foo').x.to.equal("foo");
+      expect("x").x();
+      expect(function () {
+        expect("foo").x();
+      }).to.throw(_chai.AssertionError);
+      var obj = {};
+      expect(obj).x.to.be.ok;
+      expect(obj).to.have.property('__x', 'X!');
+
+      // Test the new behavior of 'x'
+      var assertion = expect('foo').x.to.be.ok;
+      expect(_.flag(assertion, 'message')).to.equal('x marks the spot');
+      expect(function () {
+        var assertion = expect('x');
+        _.flag(assertion, 'marked', true);
+        assertion.x()
+      }).to.throw(_chai.AssertionError);
+    });
+  });
+
+});

data/components/chaijs/deep-eql/0.1.3/component.json

@@ -0,0 +1,20 @@
+{
+  "name": "deep-eql",
+  "version": "0.1.3",
+  "description": "Improved deep equality testing for Node.js and the browser.",
+  "license": "MIT",
+  "keywords": [],
+  "main": "lib/eql.js",
+  "scripts": [
+    "lib/eql.js"
+  ],
+  "dependencies": {
+    "chaijs/type-detect": "0.1.1"
+  },
+  "development": {
+    "dependencies": {
+      "chaijs/simple-assert": "1.0.0"
+    }
+  },
+  "repository": "chaijs/deep-eql"
+}

data/components/chaijs/deep-eql/0.1.3/lib/eql.js

@@ -0,0 +1,257 @@
+/*!
+ * deep-eql
+ * Copyright(c) 2013 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+/*!
+ * Module dependencies
+ */
+
+var type = require('type-detect');
+
+/*!
+ * Buffer.isBuffer browser shim
+ */
+
+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);
+  }
+}
+
+/*!
+ * Strict (egal) equality test. Ensures that NaN always
+ * equals NaN and `-0` does not equal `+0`.
+ *
+ * @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`).
+ *
+ * @param {Mixed} a
+ * @param {Mixed} b
+ * @return {Boolean} result
+ */
+
+function typeEqual(a, b) {
+  return type(a) === type(b);
+}
+
+/*!
+ * 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());
+}
+
+/*!
+ * Compare two regular expressions by converting them
+ * to string and checking for `sameValue`.
+ *
+ * @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.
+ *
+ * @param {Arguments} a
+ * @param {Arguments} b
+ * @param {Array} memoize (optional)
+ * @return {Boolean} result
+ */
+
+function argumentsEqual(a, b, m) {
+  if ('arguments' !== type(b)) return false;
+  a = [].slice.call(a);
+  b = [].slice.call(b);
+  return deepEqual(a, b, m);
+}
+
+/*!
+ * Get enumerable properties of a given object.
+ *
+ * @param {Object} a
+ * @return {Array} property names
+ */
+
+function enumerable(a) {
+  var res = [];
+  for (var key in a) res.push(key);
+  return res;
+}
+
+/*!
+ * Simple equality for flat iterable objects
+ * such as Arrays or Node.js buffers.
+ *
+ * @param {Iterable} a
+ * @param {Iterable} b
+ * @return {Boolean} result
+ */
+
+function iterableEqual(a, b) {
+  if (a.length !==  b.length) return false;
+
+  var i = 0;
+  var match = true;
+
+  for (; i < a.length; i++) {
+    if (a[i] !== b[i]) {
+      match = false;
+      break;
+    }
+  }
+
+  return match;
+}
+
+/*!
+ * Extension to `iterableEqual` specifically
+ * for Node.js Buffers.
+ *
+ * @param {Buffer} a
+ * @param {Mixed} b
+ * @return {Boolean} result
+ */
+
+function bufferEqual(a, b) {
+  if (!Buffer.isBuffer(b)) return false;
+  return iterableEqual(a, b);
+}
+
+/*!
+ * Block for `objectEqual` ensuring non-existing
+ * values don't get in.
+ *
+ * @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.
+ *
+ * @param {Mixed} a
+ * @param {Mixed} b
+ * @return {Boolean} result
+ */
+
+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;
+      }
+    }
+  } 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;
+}

data/components/chaijs/type-detect/0.1.1/component.json

@@ -0,0 +1,18 @@
+{
+  "name": "type-detect",
+  "version": "0.1.1",
+  "description": "Improved typeof detection for node.js and the browser.",
+  "license": "MIT",
+  "keywords": [],
+  "main": "lib/type.js",
+  "scripts": [
+    "lib/type.js"
+  ],
+  "dependencies": {},
+  "development": {
+    "dependencies": {
+      "chaijs/simple-assert": "*"
+    }
+  },
+  "repository": "chaijs/type-detect"
+}