ende 0.5.6 → 0.5.7

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

@@ -1,309 +0,0 @@
-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

@@ -1,20 +0,0 @@
-{
-  "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

@@ -1,257 +0,0 @@
-/*!
- * 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;
-}