ende 0.2.9 → 0.2.10

data/vendor/components/indefinido-indemma/component.json

@@ -2,10 +2,10 @@
   "name": "indemma",
   "repo": "indefinido/indemma",
   "description": "Indemma (mind picture = memory), client side ES5 observable REST model",
-  "version": "0.1.2",
+  "version": "0.1.5",
   "keywords": [],
   "dependencies": {
-    "pluma/assimilate": "*",
+    "pluma/assimilate": "0.3.0",
     "component/type": "*",
     "component/bind": "*",
     "component/jquery": "*",
@@ -18,8 +18,12 @@
     "index.js",
     "vendor/stampit.js",
     "vendor/sinon.js",
+    "vendor/owl/pluralize.js",
     "lib/record.js",
     "lib/record/associable.js",
+    "lib/record/persistable.js",
+    "lib/record/storable.js",
+    "lib/record/queryable.js",
     "lib/record/resource.js",
     "lib/record/rest.js",
     "lib/record/restfulable.js",
@@ -35,4 +39,4 @@
     "lib/record/validatable.js",
     "lib/extensions/rivets.js"
   ]
-}
+}

data/vendor/components/indefinido-indemma/components/chaijs-assertion-error/component.json

@@ -0,0 +1,18 @@
+{
+  "name": "assertion-error",
+  "repo": "chaijs/assertion-error",
+  "version": "1.0.0",
+  "description": "Error constructor for test and validation frameworks that implements standardized AssertionError specification.",
+  "license": "MIT",
+  "keywords": [
+    "test",
+    "assertion",
+    "assertion-error"
+  ],
+  "main": "index.js",
+  "scripts": [
+    "index.js"
+  ],
+  "dependencies": {},
+  "development": {}
+}

data/vendor/components/indefinido-indemma/components/chaijs-assertion-error/index.js

@@ -0,0 +1,110 @@
+/*!
+ * assertion-error
+ * Copyright(c) 2013 Jake Luer <jake@qualiancy.com>
+ * MIT Licensed
+ */
+
+/*!
+ * Return a function that will copy properties from
+ * one object to another excluding any originally
+ * listed. Returned function will create a new `{}`.
+ *
+ * @param {String} excluded properties ...
+ * @return {Function}
+ */
+
+function exclude () {
+  var excludes = [].slice.call(arguments);
+
+  function excludeProps (res, obj) {
+    Object.keys(obj).forEach(function (key) {
+      if (!~excludes.indexOf(key)) res[key] = obj[key];
+    });
+  }
+
+  return function extendExclude () {
+    var args = [].slice.call(arguments)
+      , i = 0
+      , res = {};
+
+    for (; i < args.length; i++) {
+      excludeProps(res, args[i]);
+    }
+
+    return res;
+  };
+};
+
+/*!
+ * Primary Exports
+ */
+
+module.exports = AssertionError;
+
+/**
+ * ### AssertionError
+ *
+ * An extension of the JavaScript `Error` constructor for
+ * assertion and validation scenarios.
+ *
+ * @param {String} message
+ * @param {Object} properties to include (optional)
+ * @param {callee} start stack function (optional)
+ */
+
+function AssertionError (message, _props, ssf) {
+  var extend = exclude('name', 'message', 'stack', 'constructor', 'toJSON')
+    , props = extend(_props || {});
+
+  // default values
+  this.message = message || 'Unspecified AssertionError';
+  this.showDiff = false;
+
+  // copy from properties
+  for (var key in props) {
+    this[key] = props[key];
+  }
+
+  // capture stack trace
+  ssf = ssf || arguments.callee;
+  if (ssf && Error.captureStackTrace) {
+    Error.captureStackTrace(this, ssf);
+  }
+}
+
+/*!
+ * Inherit from Error.prototype
+ */
+
+AssertionError.prototype = Object.create(Error.prototype);
+
+/*!
+ * Statically set name
+ */
+
+AssertionError.prototype.name = 'AssertionError';
+
+/*!
+ * Ensure correct constructor
+ */
+
+AssertionError.prototype.constructor = AssertionError;
+
+/**
+ * Allow errors to be converted to JSON for static transfer.
+ *
+ * @param {Boolean} include stack (default: `true`)
+ * @return {Object} object that can be `JSON.stringify`
+ */
+
+AssertionError.prototype.toJSON = function (stack) {
+  var extend = exclude('constructor', 'toJSON', 'stack')
+    , props = extend({ name: this.name }, this);
+
+  // include stack if exists and not turned off
+  if (false !== stack && this.stack) {
+    props.stack = this.stack;
+  }
+
+  return props;
+};

data/vendor/components/indefinido-indemma/components/chaijs-chai/component.json

@@ -0,0 +1,47 @@
+{
+  "name": "chai",
+  "repo": "chaijs/chai",
+  "version": "1.7.2",
+  "description": "BDD/TDD assertion library for node.js and the browser. Test framework agnostic.",
+  "license": "MIT",
+  "keywords": [
+    "test",
+    "assertion",
+    "assert",
+    "testing",
+    "chai"
+  ],
+  "main": "index.js",
+  "scripts": [
+    "index.js",
+    "lib/chai.js",
+    "lib/chai/assertion.js",
+    "lib/chai/core/assertions.js",
+    "lib/chai/interface/assert.js",
+    "lib/chai/interface/expect.js",
+    "lib/chai/interface/should.js",
+    "lib/chai/utils/addChainableMethod.js",
+    "lib/chai/utils/addMethod.js",
+    "lib/chai/utils/addProperty.js",
+    "lib/chai/utils/eql.js",
+    "lib/chai/utils/flag.js",
+    "lib/chai/utils/getActual.js",
+    "lib/chai/utils/getEnumerableProperties.js",
+    "lib/chai/utils/getMessage.js",
+    "lib/chai/utils/getName.js",
+    "lib/chai/utils/getPathValue.js",
+    "lib/chai/utils/getProperties.js",
+    "lib/chai/utils/index.js",
+    "lib/chai/utils/inspect.js",
+    "lib/chai/utils/objDisplay.js",
+    "lib/chai/utils/overwriteMethod.js",
+    "lib/chai/utils/overwriteProperty.js",
+    "lib/chai/utils/test.js",
+    "lib/chai/utils/transferFlags.js",
+    "lib/chai/utils/type.js"
+  ],
+  "dependencies": {
+    "chaijs/assertion-error": "1.0.0"
+  },
+  "development": {}
+}

data/vendor/components/indefinido-indemma/components/chaijs-chai/index.js

@@ -0,0 +1 @@
+module.exports = require('./lib/chai');

data/vendor/components/indefinido-indemma/components/chaijs-chai/lib/chai/assertion.js

@@ -0,0 +1,130 @@
+/*!
+ * chai
+ * http://chaijs.com
+ * Copyright(c) 2011-2013 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+module.exports = function (_chai, util) {
+  /*!
+   * Module dependencies.
+   */
+
+  var AssertionError = _chai.AssertionError
+    , flag = util.flag;
+
+  /*!
+   * Module export.
+   */
+
+  _chai.Assertion = Assertion;
+
+  /*!
+   * Assertion Constructor
+   *
+   * Creates object for chaining.
+   *
+   * @api private
+   */
+
+  function Assertion (obj, msg, stack) {
+    flag(this, 'ssfi', stack || arguments.callee);
+    flag(this, 'object', obj);
+    flag(this, 'message', msg);
+  }
+
+  /*!
+    * ### Assertion.includeStack
+    *
+    * User configurable property, influences whether stack trace
+    * is included in Assertion error message. Default of false
+    * suppresses stack trace in the error message
+    *
+    *     Assertion.includeStack = true;  // enable stack on error
+    *
+    * @api public
+    */
+
+  Assertion.includeStack = false;
+
+  /*!
+   * ### Assertion.showDiff
+   *
+   * User configurable property, influences whether or not
+   * the `showDiff` flag should be included in the thrown
+   * AssertionErrors. `false` will always be `false`; `true`
+   * will be true when the assertion has requested a diff
+   * be shown.
+   *
+   * @api public
+   */
+
+  Assertion.showDiff = true;
+
+  Assertion.addProperty = function (name, fn) {
+    util.addProperty(this.prototype, name, fn);
+  };
+
+  Assertion.addMethod = function (name, fn) {
+    util.addMethod(this.prototype, name, fn);
+  };
+
+  Assertion.addChainableMethod = function (name, fn, chainingBehavior) {
+    util.addChainableMethod(this.prototype, name, fn, chainingBehavior);
+  };
+
+  Assertion.overwriteProperty = function (name, fn) {
+    util.overwriteProperty(this.prototype, name, fn);
+  };
+
+  Assertion.overwriteMethod = function (name, fn) {
+    util.overwriteMethod(this.prototype, name, fn);
+  };
+
+  /*!
+   * ### .assert(expression, message, negateMessage, expected, actual)
+   *
+   * Executes an expression and check expectations. Throws AssertionError for reporting if test doesn't pass.
+   *
+   * @name assert
+   * @param {Philosophical} expression to be tested
+   * @param {String} message to display if fails
+   * @param {String} negatedMessage to display if negated expression fails
+   * @param {Mixed} expected value (remember to check for negation)
+   * @param {Mixed} actual (optional) will default to `this.obj`
+   * @api private
+   */
+
+  Assertion.prototype.assert = function (expr, msg, negateMsg, expected, _actual, showDiff) {
+    var ok = util.test(this, arguments);
+    if (true !== showDiff) showDiff = false;
+    if (true !== Assertion.showDiff) showDiff = false;
+
+    if (!ok) {
+      var msg = util.getMessage(this, arguments)
+        , actual = util.getActual(this, arguments);
+      throw new AssertionError(msg, {
+          actual: actual
+        , expected: expected
+        , showDiff: showDiff
+      }, (Assertion.includeStack) ? this.assert : flag(this, 'ssfi'));
+    }
+  };
+
+  /*!
+   * ### ._obj
+   *
+   * Quick reference to stored `actual` value for plugin developers.
+   *
+   * @api private
+   */
+
+  Object.defineProperty(Assertion.prototype, '_obj',
+    { get: function () {
+        return flag(this, 'object');
+      }
+    , set: function (val) {
+        flag(this, 'object', val);
+      }
+  });
+};