ende 0.2.9 → 0.2.10

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

@@ -0,0 +1,25 @@
+{
+  "name": "assimilate",
+  "version": "0.3.0",
+  "license": "MIT",
+  "repo": "pluma/assimilate",
+  "description": "Extends objects.",
+  "keywords": [
+    "extend",
+    "inherit",
+    "mixin"
+  ],
+  "main": "./dist/assimilate.js",
+  "dependencies": {},
+  "development": {},
+  "scripts": [
+    "dist/assimilate.js"
+  ],
+  "styles": [],
+  "ignore": [
+    "**/.*",
+    "build",
+    "components",
+    "node_modules"
+  ]
+}

data/vendor/components/indefinido-indemma/components/pluma-assimilate/dist/assimilate.js

@@ -0,0 +1,127 @@
+/*! assimilate 0.3.0 Copyright (c) 2013 Alan Plum. MIT licensed. */
+var slice = Array.prototype.slice;
+
+function bind(fn, self) {
+    var args = slice.call(arguments, 2);
+    if (typeof Function.prototype.bind === 'function') {
+        return Function.prototype.bind.apply(fn, [self].concat(args));
+    }
+    return function() {
+        return fn.apply(self, args.concat(slice.call(arguments, 0)));
+    };
+}
+
+function simpleCopy(target, name, source) {
+    target[name] = source[name];
+}
+
+function properCopy(target, name, source) {
+    var descriptor = Object.getOwnPropertyDescriptor(source, name);
+    Object.defineProperty(target, name, descriptor);
+}
+
+function ownProperties(obj) {
+    return Object.getOwnPropertyNames(obj);
+}
+
+function allKeys(obj) {
+    var keys = [];
+    for (var name in obj) {
+        keys.push(name);
+    }
+    return keys;
+}
+
+function ownKeys(obj) {
+    var keys = [];
+    for (var name in obj) {
+        if (obj.hasOwnProperty(name)) {
+            keys.push(name);
+        }
+    }
+    return keys;
+}
+
+function assimilateWithStrategy(target) {
+    var strategy = this,
+    sources = slice.call(arguments, 1),
+    i, source, names, j, name;
+
+    if (target === undefined || target === null) {
+        target = {};
+    }
+
+    for (i = 0; i < sources.length; i++) {
+        source = sources[i];
+        names = strategy.keysFn(source);
+        for (j = 0; j < names.length; j++) {
+            name = names[j];
+            strategy.copyFn(target, name, source);
+        }
+    }
+
+    return target;
+}
+
+var strategies = {
+    DEFAULT: {
+        keysFn: ownKeys,
+        copyFn: simpleCopy
+    },
+    PROPER: {
+        keysFn: ownProperties,
+        copyFn: properCopy
+    },
+    INHERITED: {
+        keysFn: allKeys,
+        copyFn: simpleCopy
+    },
+    DEEP: {
+        keysFn: ownKeys,
+        copyFn: function recursiveCopy(target, name, source) {
+            var val = source[name];
+            var old = target[name];
+            if (typeof val === 'object' && typeof old === 'object') {
+                assimilateWithStrategy.call(strategies.DEEP, old, val);
+            } else {
+                simpleCopy(target, name, source);
+            }
+        }
+    },
+    STRICT: {
+        keysFn: ownKeys,
+        copyFn: function strictCopy(target, name, source) {
+            if (source[name] !== undefined) {
+                simpleCopy(target, name, source);
+            }
+        }
+    },
+    FALLBACK: {
+        keysFn: function fallbackCopy(target, name, source) {
+            if (target[name] === undefined) {
+                simpleCopy(target, name, source);
+            }
+        },
+        copyFn: simpleCopy
+    }
+};
+
+var assimilate = bind(assimilateWithStrategy, strategies.DEFAULT);
+assimilate.strategies = strategies;
+assimilate.withStrategy = function withStrategy(strategy) {
+    if (typeof strategy === 'string') {
+        strategy = strategies[strategy.toUpperCase()];
+    }
+    if (!strategy) {
+        throw new Error('Unknwon or invalid strategy:' + strategy);
+    }
+    if (typeof strategy.copyFn !== 'function') {
+        throw new Error('Strategy missing copy function:' + strategy);
+    }
+    if (typeof strategy.keysFn !== 'function') {
+        throw new Error('Strategy missing keys function:' + strategy);
+    }
+    return bind(assimilateWithStrategy, strategy);
+};
+
+module.exports = assimilate;

data/vendor/components/indefinido-indemma/karma.conf.js

@@ -0,0 +1,86 @@
+// Karma configuration
+// Generated on Mon May 27 2013 16:00:28 GMT-0300 (BRT)
+
+
+// base path, that will be used to resolve files and exclude
+basePath = '';
+
+// list of files / patterns to load in the browser
+files = [
+
+  // Test environment
+  MOCHA,
+  MOCHA_ADAPTER,
+  'vendor/sinon.js',
+
+  // Test dependencies
+  'build/test.js',
+  'spec/support/**/*.js',
+
+  // Test Source files
+  'spec/spec_helper.js',
+  'spec/**/*.js'
+];
+
+
+// list of files to exclude
+exclude = [
+  'spec/coverage'
+];
+
+
+// test results reporter to use
+// possible values: 'dots', 'progress', 'junit'
+reporters = ['progress', 'coverage'];
+
+
+// web server port
+port = 9876;
+
+
+// cli runner port
+runnerPort = 9100;
+
+
+// enable / disable colors in the output (reporters and logs)
+colors = true;
+
+
+// level of logging
+// possible values: LOG_DISABLE || LOG_ERROR || LOG_WARN || LOG_INFO || LOG_DEBUG
+logLevel = LOG_INFO;
+
+
+// enable / disable watching file and executing tests whenever any file changes
+autoWatch = true;
+
+
+// Start these browsers, currently available:
+// - Chrome
+// - ChromeCanary
+// - Firefox
+// - Opera
+// - Safari (only Mac)
+// - PhantomJS
+// - IE (only Windows)
+browsers = ['Chrome'];
+
+
+// If browser does not capture in given timeout [ms], kill it
+captureTimeout = 600000;
+
+
+// Continuous Integration mode
+// if true, it capture browsers, run tests and exit
+singleRun = false;
+
+// Coverage preprocessors
+preprocessors = {
+  '**/lib/*.js': 'coverage'
+};
+
+// Converage configuration
+coverageReporter = {
+  type : 'html',
+  dir  : 'spec/coverage'
+}

data/vendor/components/indefinido-indemma/lib/record/associable.js

@@ -1,10 +1,12 @@
-var $, associable, model, plural, root, singular,
+var $, associable, callbacks, extend, model, modifiers, plural, root, singular, subscribers,
   __slice = [].slice;
 
 root = window;
 
 $ = require('jquery');
 
+extend = require('assimilate');
+
 require('./resource');
 
 plural = {
@@ -48,7 +50,10 @@ plural = {
     data[_name = this.parent_resource] || (data[_name] = this.parent);
     return model[model.singularize(this.resource)](data);
   },
-  push: Array.prototype.push,
+  push: function() {
+    console.warn("" + this.resource + ".push is deprecated and will be removed, please use add instead");
+    return Array.prototype.push.apply(this, arguments);
+  },
   length: 0,
   json: function(methods, omissions) {
     var record, _i, _len, _results;
@@ -64,92 +69,192 @@ plural = {
 
 singular = {
   create: function(data) {
-    return model[this.resource].create($.extend({}, this, data));
+    return model[this.resource].create(extend({}, this, data));
   },
   build: function(data) {
-    return this[this.parent_resource][this.resource] = model[this.resource]($.extend({}, this, data));
+    return this.owner[this.resource.toString()] = model[this.resource.toString()](extend({}, this, data));
   }
 };
 
-associable = {
-  model: function(options) {
-    var callbacks;
+subscribers = {
+  belongs_to: {
+    foreign_key: function(resource_id) {
+      var associated, association_name, current_resource_id, resource, _ref;
 
-    if (this.resource == null) {
-      console.error('resource must be defined in order to associate');
+      association_name = this.resource.toString();
+      if (resource_id === null || resource_id === void 0) {
+        this.dirty = true;
+        this.owner[association_name] = resource_id;
+        return resource_id;
+      }
+      current_resource_id = (_ref = this.owner[association_name]) != null ? _ref._id : void 0;
+      if (resource_id !== current_resource_id) {
+        resource = model[association_name];
+        if (!resource) {
+          console.warn("subscribers.belongs_to.foreign_key: associated factory not found for model: " + association_name);
+          return resource_id;
+        }
+        associated = resource.find(resource_id);
+        associated || (associated = resource({
+          _id: resource_id
+        }));
+        this.owner.observed[association_name] = associated;
+      }
+      return resource_id;
+    },
+    associated_changed: function(associated) {
+      return this.owner.observed["" + (this.resource.toString()) + "_id"] = associated ? associated._id : null;
     }
-    callbacks = {
-      has_many: {
-        nest_attributes: function() {
-          var association, association_name, association_names, associations_attributes, message, _i, _len, _results;
-
-          association_names = model[this.resource].has_many;
-          if (association_names) {
-            _results = [];
-            for (_i = 0, _len = association_names.length; _i < _len; _i++) {
-              association_name = association_names[_i];
-              associations_attributes = this["" + association_name + "_attributes"];
-              if (associations_attributes && associations_attributes.length) {
-                association = this[model.pluralize(association_name)];
-                if (!association) {
-                  message = "has_many.nest_attributes: Association not found for " + association_name + ". \n";
-                  message += "did you set it on model declaration? \n  has_many: " + association_name + " ";
-                  throw message;
-                }
-                association.resource = model.singularize(association.resource);
-                association.add.apply(association, associations_attributes);
-                _results.push(association.resource = model.pluralize(association.resource));
-              } else {
-                _results.push(void 0);
-              }
-            }
-            return _results;
+  }
+};
+
+modifiers = {
+  belongs_to: {
+    associated_loader: function() {
+      var association_name,
+        _this = this;
+
+      association_name = this.resource.toString();
+      return Object.defineProperty(this.owner, association_name, {
+        set: function(associated) {
+          return this.observed[association_name] = associated;
+        },
+        get: function() {
+          var associated, associated_id, resource;
+
+          associated = _this.owner.observed[association_name];
+          associated_id = _this.owner.observed[association_name + '_id'];
+          if (!(((associated != null ? associated._id : void 0) != null) || associated_id)) {
+            return associated;
+          }
+          if (associated != null ? associated.sustained : void 0) {
+            return associated;
           }
+          resource = model[association_name];
+          if (!resource) {
+            console.warn("subscribers.belongs_to.foreign_key: associated factory not found for model: " + association_name);
+            return associated;
+          }
+          associated = resource.find(associated_id || associated._id);
+          associated || (associated = resource({
+            _id: associated_id
+          }));
+          resource.storage.store(associated._id, associated);
+          associated.reload();
+          return _this.owner.observed[association_name] = associated;
         },
-        update_association: function(data) {
-          var associated, association, association_name, id, pluralized_association, _i, _j, _len, _len1, _ref;
+        configurable: true,
+        enumerable: true
+      });
+    }
+  }
+};
 
-          id = this._id || data && (data._id || data.id);
-          if (!id) {
-            return;
+callbacks = {
+  has_many: {
+    nest_attributes: function() {
+      var association, association_name, association_names, associations_attributes, message, _i, _len, _results;
+
+      association_names = model[this.resource].has_many;
+      if (association_names) {
+        _results = [];
+        for (_i = 0, _len = association_names.length; _i < _len; _i++) {
+          association_name = association_names[_i];
+          associations_attributes = this["" + association_name + "_attributes"];
+          if (associations_attributes && associations_attributes.length) {
+            association = this[model.pluralize(association_name)];
+            if (!association) {
+              message = "has_many.nest_attributes: Association not found for " + association_name + ". \n";
+              message += "did you set it on model declaration? \n  has_many: " + association_name + " ";
+              throw message;
+            }
+            association.resource = model.singularize(association.resource);
+            association.add.apply(association, associations_attributes);
+            _results.push(association.resource = model.pluralize(association.resource));
+          } else {
+            _results.push(void 0);
           }
-          _ref = model[this.resource.toString()].has_many;
-          for (_i = 0, _len = _ref.length; _i < _len; _i++) {
-            association_name = _ref[_i];
-            pluralized_association = model.pluralize(association_name);
-            association = this[pluralized_association];
-            if (!association.route) {
-              association.route = "/" + (model.pluralize(this.resource.toString())) + "/" + id + "/" + (model.pluralize(association.resource));
-              for (_j = 0, _len1 = association.length; _j < _len1; _j++) {
-                associated = association[_j];
-                if (!associated.route && (associated.parent != null)) {
-                  associated.route = "/" + (model.pluralize(this.resource.toString())) + "/" + id + "/" + (model.pluralize(association.resource));
-                }
-              }
+        }
+        return _results;
+      }
+    },
+    update_association: function(data) {
+      var associated, association, association_name, id, pluralized_association, _i, _j, _len, _len1, _ref;
+
+      id = this._id || data && (data._id || data.id);
+      if (!id) {
+        return;
+      }
+      _ref = model[this.resource.toString()].has_many;
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        association_name = _ref[_i];
+        pluralized_association = model.pluralize(association_name);
+        association = this[pluralized_association];
+        if (!association.route) {
+          association.route = "/" + (model.pluralize(this.resource.toString())) + "/" + id + "/" + (model.pluralize(association.resource));
+          for (_j = 0, _len1 = association.length; _j < _len1; _j++) {
+            associated = association[_j];
+            if (!associated.route && (associated.parent != null)) {
+              associated.route = "/" + (model.pluralize(this.resource.toString())) + "/" + id + "/" + (model.pluralize(association.resource));
             }
           }
-          return true;
-        },
-        autosave: function() {
-          return this.save();
         }
       }
-    };
-    if (this.has_many && $.type(this.has_many) !== 'array') {
-      this.has_many = [this.has_many];
-    }
-    if (this.has_one && $.type(this.has_one) !== 'array') {
-      this.has_one = [this.has_one];
+      return true;
+    },
+    autosave: function() {
+      throw 'Not implemented yet';
     }
-    if (this.belongs_to && $.type(this.belongs_to) !== 'array') {
-      this.belongs_to = [this.belongs_to];
+  },
+  has_one: {
+    nest_attributes: function() {
+      var association_name, association_names, associations_attributes, _i, _len, _results;
+
+      association_names = model[this.resource].has_one;
+      if (association_names) {
+        _results = [];
+        for (_i = 0, _len = association_names.length; _i < _len; _i++) {
+          association_name = association_names[_i];
+          associations_attributes = this["" + association_name + "_attributes"];
+          if (associations_attributes) {
+            this[association_name] = this["build_" + association_name](associations_attributes);
+            _results.push(delete this["" + association_name + "_attributes"]);
+          } else {
+            _results.push(void 0);
+          }
+        }
+        return _results;
+      }
     }
-    this.has_many || (this.has_many = []);
-    this.has_one || (this.has_one = []);
-    this.belongs_to || (this.belongs_to = []);
-    return this.create_associations = function() {
-      var association_name, association_proxy, resource, _i, _j, _k, _len, _len1, _len2, _ref, _ref1, _ref2, _results;
+  }
+};
+
+associable = {
+  model: {
+    blender: function(definition) {
+      var model;
 
+      model = associable.model;
+      this.create_after_hooks = model.create_after_hooks;
+      this.create_before_hooks = model.create_before_hooks;
+      if (this.has_many && $.type(this.has_many) !== 'array') {
+        this.has_many = [this.has_many];
+      }
+      if (this.has_one && $.type(this.has_one) !== 'array') {
+        this.has_one = [this.has_one];
+      }
+      if (this.belongs_to && $.type(this.belongs_to) !== 'array') {
+        this.belongs_to = [this.belongs_to];
+      }
+      this.has_many || (this.has_many = []);
+      this.has_one || (this.has_one = []);
+      this.belongs_to || (this.belongs_to = []);
+      return true;
+    },
+    create_after_hooks: function(definition) {
+      var association_name, association_proxy, old_resource_id, options, resource, _i, _j, _k, _len, _len1, _len2, _ref, _ref1, _ref2, _results;
+
+      options = model[this.resource.name || this.resource.toString()];
       if (options.has_many) {
         _ref = options.has_many;
         for (_i = 0, _len = _ref.length; _i < _len; _i++) {
@@ -171,12 +276,14 @@ associable = {
           resource = _ref1[_j];
           association_proxy = {
             resource: resource,
-            parent_resource: this.resource
+            parent_resource: this.resource,
+            owner: this
           };
-          association_proxy[this.resource] = this;
+          association_proxy[this.resource.toString()] = this;
           this["build_" + resource] = $.proxy(singular.build, association_proxy);
           this["create_" + resource] = $.proxy(singular.create, association_proxy);
         }
+        callbacks.has_one.nest_attributes.call(this);
       }
       if (options.belongs_to) {
         _ref2 = options.belongs_to;
@@ -185,29 +292,69 @@ associable = {
           resource = _ref2[_k];
           association_proxy = {
             resource: resource,
-            parent_resource: this.resource
+            parent_resource: this.resource,
+            parent: this,
+            owner: this
           };
-          association_proxy[this.resource] = this;
+          association_proxy[this.resource.toString()] = this;
           this["build_" + resource] = $.proxy(singular.build, association_proxy);
-          _results.push(this["create_" + resource] = $.proxy(singular.create, association_proxy));
+          this["create_" + resource] = $.proxy(singular.create, association_proxy);
+          old_resource_id = this["" + resource + "_id"];
+          this["" + resource + "_id"] = null;
+          this.subscribe("" + resource + "_id", $.proxy(subscribers.belongs_to.foreign_key, association_proxy));
+          this.subscribe(resource.toString(), $.proxy(subscribers.belongs_to.associated_changed, association_proxy));
+          this.resource_id = old_resource_id;
+          if (this["" + resource + "_id"] && !this[resource]) {
+            _results.push(this.publish("" + resource + "_id", this["" + resource + "_id"]));
+          } else {
+            _results.push(void 0);
+          }
         }
         return _results;
       }
-    };
+    },
+    create_before_hooks: function(record) {
+      var association_proxy, definition, resource, _i, _len, _ref, _results;
+
+      definition = this;
+      if (definition.belongs_to) {
+        _ref = definition.belongs_to;
+        _results = [];
+        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+          resource = _ref[_i];
+          association_proxy = {
+            resource: resource,
+            parent_resource: this.resource,
+            owner: record
+          };
+          _results.push(modifiers.belongs_to.associated_loader.call(association_proxy));
+        }
+        return _results;
+      }
+    }
   },
-  record: function(options) {
-    if (this.resource == null) {
-      console.error('resource must be defined in order to associate');
+  record: {
+    after_initialize: function(attributes) {
+      if (this.resource == null) {
+        throw new Error('resource must be defined in order to associate');
+      }
+      return model[this.resource.name || this.resource.toString()].create_after_hooks.call(this);
+    },
+    before_initialize: function(creation) {
+      if (!this.resource) {
+        throw new Error('resource must be defined in order to associate');
+      }
+      return model[this.resource.name || this.resource.toString()].create_before_hooks(creation);
     }
-    return model[this.resource.name || this.resource.toString()].create_associations.call(this);
   }
 };
 
 model = root.model;
 
 model.mix(function(modelable) {
-  modelable.after_mix.push(associable.model);
-  return modelable.record.after_initialize.push(associable.record);
+  modelable.after_mix.push(associable.model.blender);
+  modelable.record.before_initialize.push(associable.record.before_initialize);
+  return modelable.record.after_initialize.push(associable.record.after_initialize);
 });
 
 model.associable = {

data/vendor/components/indefinido-indemma/lib/record/errors.js

@@ -0,0 +1 @@
+

data/vendor/components/indefinido-indemma/lib/record/persistable.js

@@ -0,0 +1,32 @@
+var handlers, model, persistable, record;
+
+require('./queryable');
+
+handlers = {
+  store_after_saved: function() {
+    var storage;
+
+    storage = model[this.resource.toString()].storage;
+    if (this._id) {
+      return storage.store(this._id, this);
+    }
+  }
+};
+
+persistable = {
+  record: {
+    after_initialize: function() {
+      return this.after('saved', handlers.store_after_saved);
+    }
+  }
+};
+
+model = window.model;
+
+record = window.record;
+
+model.persistable = true;
+
+model.mix(function(modelable) {
+  return modelable.record.after_initialize.push(persistable.record.after_initialize);
+});