ende 0.1.4 → 0.1.5

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

@@ -0,0 +1,217 @@
+var $, associable, model, plural, root, singular,
+  __slice = [].slice;
+
+root = window;
+
+$ = require('jquery');
+
+require('./resource');
+
+plural = {
+  add: function() {
+    var attributes, params, _i, _len, _results;
+
+    params = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+    _results = [];
+    for (_i = 0, _len = params.length; _i < _len; _i++) {
+      attributes = params[_i];
+      _results.push(this.push(this.build(attributes)));
+    }
+    return _results;
+  },
+  create: function() {
+    var attributes, params, record, _i, _len, _results;
+
+    params = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+    _results = [];
+    for (_i = 0, _len = params.length; _i < _len; _i++) {
+      attributes = params[_i];
+      record = this.build(attributes);
+      this.push(record);
+      _results.push(record.save());
+    }
+    return _results;
+  },
+  build: function(data) {
+    var _name;
+
+    if (data == null) {
+      data = {};
+    }
+    data.parent_resource = this.parent_resource;
+    if (this.parent != null) {
+      data.route || (data.route = "" + this.parent.route + "/" + this.parent._id + "/" + (model.pluralize(this.resource.toString())));
+    }
+    if (this.route !== data.route && this.route) {
+      throw "associable.has_many: cannot redefine route of association " + this.parent_resource + "." + this.resource + " from " + this.route + " to " + data.route;
+    }
+    data[_name = this.parent_resource] || (data[_name] = this.parent);
+    return model[model.singularize(this.resource)](data);
+  },
+  push: Array.prototype.push,
+  length: 0,
+  json: function() {
+    var record, _i, _len, _results;
+
+    _results = [];
+    for (_i = 0, _len = this.length; _i < _len; _i++) {
+      record = this[_i];
+      _results.push(record.json());
+    }
+    return _results;
+  }
+};
+
+singular = {
+  create: function(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));
+  }
+};
+
+associable = {
+  model: function(options) {
+    var callbacks;
+
+    if (this.resource == null) {
+      console.error('resource must be defined in order to associate');
+    }
+    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;
+          }
+        },
+        update_association: function(data) {
+          var associated, association, association_name, id, pluralized_association, _i, _j, _len, _len1, _ref;
+
+          id = this._id || data._id || data.id;
+          if (!id) {
+            return;
+          }
+          _ref = model[this.resource].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)) + "/" + 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)) + "/" + 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];
+    }
+    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 this.create_associations = function() {
+      var association_name, association_proxy, resource, _i, _j, _k, _len, _len1, _len2, _ref, _ref1, _ref2, _results;
+
+      if (options.has_many) {
+        _ref = options.has_many;
+        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+          resource = _ref[_i];
+          association_proxy = {
+            resource: resource,
+            parent_resource: this.resource,
+            parent: this
+          };
+          association_name = model.pluralize(resource);
+          this[association_name] = $.extend(association_proxy, plural);
+        }
+        this.after('saved', callbacks.has_many.update_association);
+        callbacks.has_many.nest_attributes.call(this);
+      }
+      if (options.has_one) {
+        _ref1 = options.has_one;
+        for (_j = 0, _len1 = _ref1.length; _j < _len1; _j++) {
+          resource = _ref1[_j];
+          association_proxy = {
+            resource: resource,
+            parent_resource: this.resource
+          };
+          association_proxy[this.resource] = this;
+          this["build_" + resource] = $.proxy(singular.build, association_proxy);
+          this["create_" + resource] = $.proxy(singular.create, association_proxy);
+        }
+      }
+      if (options.belongs_to) {
+        _ref2 = options.belongs_to;
+        _results = [];
+        for (_k = 0, _len2 = _ref2.length; _k < _len2; _k++) {
+          resource = _ref2[_k];
+          association_proxy = {
+            resource: resource,
+            parent_resource: this.resource
+          };
+          association_proxy[this.resource] = this;
+          this["build_" + resource] = $.proxy(singular.build, association_proxy);
+          _results.push(this["create_" + resource] = $.proxy(singular.create, association_proxy));
+        }
+        return _results;
+      }
+    };
+  },
+  record: function(options) {
+    if (this.resource == null) {
+      console.error('resource must be defined in order to associate');
+    }
+    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);
+});
+
+model.associable = {
+  mix: function(blender) {
+    return blender(singular, plural);
+  }
+};

data/vendor/assets/components/indefinido-indemma/lib/record/maid.js

@@ -0,0 +1,24 @@
+var maid, model;
+
+maid = {
+  model: function() {
+    if (this.washing != null) {
+      return this.record.after_initialize.push(maid.record);
+    }
+  },
+  record: function() {
+    return this.subscribe('dirty', function(dirty) {
+      var _this = this;
+
+      return dirty && setTimeout(function() {
+        return _this.save();
+      }, 500);
+    });
+  }
+};
+
+model = window.model;
+
+model.mix(function(modelable) {
+  return modelable.after_mix.unshift(maid.model);
+});

data/vendor/assets/components/indefinido-indemma/lib/record/resource.js

@@ -0,0 +1,104 @@
+var model, resource, resourceable, stampit;
+
+stampit = require('../../vendor/stampit');
+
+resource = stampit({
+  toString: function() {
+    return this.name;
+  }
+}, {
+  name: 'unknown',
+  scope: null,
+  singular: false
+}, function() {
+  this.param_name || (this.param_name = this.name);
+  return this;
+});
+
+resourceable = {
+  pluralize: function(word) {
+    if (!(word && word.length)) {
+      throw new TypeError("Invalid string passed to pluralize '" + word + "'");
+    }
+    if (word.indexOf('s') !== word.length - 1) {
+      return word + 's';
+    } else {
+      return word;
+    }
+  },
+  singularize: function(word) {
+    if (!(word && word.length)) {
+      throw new TypeError("Invalid string passed to singularize '" + word + "'");
+    }
+    if (word.indexOf('s') === word.length - 1) {
+      return word.substring(0, word.length - 1);
+    } else {
+      return word;
+    }
+  },
+  route: {
+    get: function() {
+      var route;
+
+      if (this.initial_route != null) {
+        return this.initial_route;
+      }
+      if (typeof this.resource === 'string') {
+        this.resource = {
+          name: this.resource
+        };
+      }
+      route = '/';
+      if (this.parent != null) {
+        route += "" + this.parent.route + "/" + this.parent._id + "/";
+      }
+      if (this.resource.scope != null) {
+        route += this.resource.scope + '/';
+      }
+      route += this.resource.singular ? this.resource.name : model.pluralize(this.resource.name);
+      this.initial_route = route;
+      return route;
+    },
+    set: function(value) {
+      return this.initial_route = value;
+    }
+  },
+  parent_id: {
+    get: function() {
+      return this[this.parent_resource]._id;
+    },
+    set: function() {
+      return console.error('Warning changing associations throught parent_id not allowed for security and style guide purposes');
+    }
+  },
+  initialize: function() {
+    var resource_definition, _ref;
+
+    if (this.parent_resource) {
+      Object.defineProperty(this, "" + this.parent_resource + "_id", resourceable.parent_id);
+    }
+    resource_definition = {};
+    if (typeof this.resource === 'string') {
+      resource_definition = {
+        name: this.resource
+      };
+    }
+    if (typeof this.resource === 'object') {
+      resource_definition = this.resource;
+    }
+    resource_definition.parent = this.parent_resource;
+    this.resource = resource(resource_definition);
+    return (_ref = this.route) != null ? _ref : Object.defineProperty(this, 'route', resourceable.route);
+  }
+};
+
+model = window.model;
+
+model.mix(function(modelable) {
+  modelable.record.after_initialize.unshift(resourceable.initialize);
+  return modelable.after_mix.unshift(resourceable.initialize);
+});
+
+model.singularize = resourceable.singularize;
+
+model.pluralize = resourceable.pluralize;

data/vendor/assets/components/indefinido-indemma/lib/record/rest.js

@@ -0,0 +1,36 @@
+var $, request;
+
+$ = require('jquery');
+
+module.exports = {
+  get: function(data) {
+    return request.call(this, 'get', (this._id ? "" + this.route + "/" + this._id : this.route), data);
+  },
+  put: function(data) {
+    return request.call(this, 'put', "" + this.route + "/" + this._id, data);
+  },
+  post: function(data) {
+    return request.call(this, 'post', this.route, data);
+  }
+};
+
+request = function(method, url, data) {
+  var param_name;
+
+  param_name = this.resource.param_name || this.resource.toString();
+  if (!data && this.json) {
+    data = {};
+    data[param_name] = this.json();
+  }
+  if (data[param_name]) {
+    delete data[param_name]._id;
+    delete data[param_name].id;
+  }
+  return $.ajax({
+    url: url,
+    data: data,
+    type: method,
+    dataType: 'json',
+    context: this
+  });
+};

data/vendor/assets/components/indefinido-indemma/lib/record/restfulable.js

@@ -0,0 +1,326 @@
+var $, merge, model, observable, record, rest, restful, type, util,
+  __slice = [].slice;
+
+merge = require('assimilate').withStrategy('deep');
+
+type = require('type');
+
+observable = require('observable').mixin;
+
+$ = require('jquery');
+
+rest = require('./rest.js');
+
+util = {
+  model: {
+    map: function(models) {
+      var model, _i, _len, _results;
+
+      _results = [];
+      for (_i = 0, _len = models.length; _i < _len; _i++) {
+        model = models[_i];
+        _results.push(this(model));
+      }
+      return _results;
+    }
+  }
+};
+
+restful = {
+  model: {
+    create: function() {
+      var attributes, callback, params, record, _i, _j, _len, _results;
+
+      params = 2 <= arguments.length ? __slice.call(arguments, 0, _i = arguments.length - 1) : (_i = 0, []), callback = arguments[_i++];
+      if (!arguments.length) {
+        throw new TypeError("No arguments provided for " + this.resource + ".create");
+      }
+      if (typeof callback !== 'function') {
+        params.push(callback);
+      }
+      if (!params.length) {
+        params.unshift({});
+      }
+      _results = [];
+      for (_j = 0, _len = params.length; _j < _len; _j++) {
+        attributes = params[_j];
+        record = this(attributes);
+        record.dirty = true;
+        _results.push(record.save(callback));
+      }
+      return _results;
+    },
+    all: function(conditions, callback) {
+      if (conditions == null) {
+        conditions = {};
+      }
+      if (typeof conditions === 'function') {
+        callback = conditions;
+        conditions = {};
+      }
+      return $.when(rest.get.call(this, conditions)).then(util.model.map).done(callback);
+    },
+    first: function(conditions, callback) {
+      var namespaced;
+
+      if (conditions == null) {
+        conditions = {};
+      }
+      if (typeof conditions === 'function') {
+        callback = conditions;
+        conditions = {};
+      }
+      namespaced = conditions[this.resource] || {};
+      namespaced.limit = 1;
+      namespaced.order = 'desc';
+      return this.all(conditions, callback);
+    },
+    get: function(action, data) {
+      var old_route, payload, promise, resource, route;
+
+      old_route = this.route;
+      this.route = "/" + (model.pluralize(this.resource.name)) + "/" + action;
+      resource = data.resource;
+      if (data && data.json) {
+        data = data.json();
+      }
+      if (resource != null) {
+        payload = data;
+        data = {};
+        data[resource] = payload;
+      }
+      promise = rest.get.call(this, data);
+      route = old_route;
+      return promise;
+    }
+  },
+  record: {
+    reload: function() {
+      var argument, promise, _i, _len;
+
+      promise = rest.get.call(this);
+      promise.done(this.assign_attributes);
+      promise.fail(this.failed);
+      for (_i = 0, _len = arguments.length; _i < _len; _i++) {
+        argument = arguments[_i];
+        if (type(argument) === 'function') {
+          promise.done(argument);
+        }
+      }
+      return promise;
+    },
+    assign_attributes: function(attributes) {
+      var association, association_attributes, association_name, associations_attributes, attribute, message, singular_resource, _i, _j, _k, _l, _len, _len1, _len2, _len3, _ref, _ref1, _ref2, _results;
+
+      _ref = model[this.resource.toString()].has_many;
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        association_name = _ref[_i];
+        associations_attributes = attributes[association_name];
+        delete attributes[association_name];
+        association = this[association_name];
+        if (association == null) {
+          message = "Association '" + association_name + "' not found. \n";
+          message += "For record with resource " + this.resource + ". \n";
+          message += "Probably defined on server side but not on client side.\n";
+          message += "Skipping association assignment!";
+          console.warn(message);
+          continue;
+        }
+        if (association.length) {
+          Array.prototype.splice.call(association, 0);
+        }
+        if (!((associations_attributes != null) && associations_attributes.length)) {
+          continue;
+        }
+        singular_resource = model.singularize(association_name);
+        for (_j = 0, _len1 = associations_attributes.length; _j < _len1; _j++) {
+          association_attributes = associations_attributes[_j];
+          _ref1 = model[singular_resource].has_many;
+          for (_k = 0, _len2 = _ref1.length; _k < _len2; _k++) {
+            association_name = _ref1[_k];
+            association_attributes["" + association_name + "_attributes"] = association_attributes[association_name];
+            delete association_attributes[association_name];
+          }
+        }
+        association.add.apply(association, associations_attributes);
+      }
+      _ref2 = model[this.resource.toString()].has_one;
+      for (_l = 0, _len3 = _ref2.length; _l < _len3; _l++) {
+        association_name = _ref2[_l];
+        association_attributes = attributes[association_name];
+        delete attributes[association_name];
+        if (association_attributes) {
+          this[association_name] = this["build_" + association_name](association_attributes);
+        }
+      }
+      _results = [];
+      for (attribute in attributes) {
+        _results.push(this[attribute] = attributes[attribute]);
+      }
+      return _results;
+    },
+    save: function(doned, failed, data) {
+      var promise;
+
+      if (!this.dirty) {
+        return $.Deferred().resolve();
+      }
+      promise = rest[this._id ? 'put' : 'post'].call(this, data);
+      promise.done(this.saved);
+      promise.fail(this.failed);
+      promise.done(doned);
+      promise.fail(failed);
+      this.lock = JSON.stringify(this.json());
+      return promise;
+    },
+    saved: function(data) {
+      var callback, _i, _len, _ref, _results;
+
+      if (this.lock === JSON.stringify(this.json())) {
+        this.dirty = false;
+        delete this.lock;
+      } else {
+        return this.save();
+      }
+      if (data != null) {
+        this.assign_attributes(data);
+      }
+      if (this.after_save) {
+        _ref = this.after_save;
+        _results = [];
+        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+          callback = _ref[_i];
+          throw "Not supported after_save callback: " + callback;
+        }
+        return _results;
+      }
+    },
+    failed: function(xhr, error, status) {
+      var attribute_name, definition, e, message, messages, payload, _ref, _results;
+
+      payload = xhr.responseJSON;
+      try {
+        payload || (payload = JSON.parse(xhr.responseText));
+      } catch (_error) {
+        e = _error;
+      }
+      payload || (payload = xhr.responseText);
+      switch (xhr.status) {
+        case 422:
+          definition = model[this.resource];
+          _ref = payload.errors;
+          _results = [];
+          for (attribute_name in _ref) {
+            messages = _ref[attribute_name];
+            if (!(this.hasOwnProperty(attribute_name) || definition.hasOwnProperty(attribute_name))) {
+              message = "Server returned an validation error message for a attribute that is not defined in your model.\n";
+              message += "The attribute was '" + attribute_name + "', the model resource was '" + this.resource + "'.\n";
+              message += "The model definition keys were '" + (JSON.stringify(Object.keys(definition))) + "'.\n";
+              message += "Please remove server validation, or update your model definition.";
+              throw new TypeError(message);
+            }
+            _results.push((function() {
+              var _i, _len, _results1;
+
+              _results1 = [];
+              for (_i = 0, _len = messages.length; _i < _len; _i++) {
+                message = messages[_i];
+                _results1.push(this.errors.add(attribute_name, 'server', {
+                  server_message: message
+                }));
+              }
+              return _results1;
+            }).call(this));
+          }
+          return _results;
+          break;
+        default:
+          message = "Fail in " + this.resource + ".save:\n";
+          message += "Record: " + this + "\n";
+          message += "Status: " + status + " (" + (payload.status || xhr.status) + ")\n";
+          return message += "Error : " + (payload.error || payload.message || payload);
+      }
+    },
+    toString: function() {
+      var serialized;
+
+      serialized = {};
+      serialized[this.resource] = this.json();
+      return JSON.stringify(serialized);
+    },
+    json: function() {
+      var attribute, json, name, value, _i, _len, _ref;
+
+      json = {};
+      for (name in this) {
+        value = this[name];
+        if (!(type(value) !== 'function')) {
+          continue;
+        }
+        if (value == null) {
+          continue;
+        }
+        if (type(value) === 'object') {
+          if (value.toJSON != null) {
+            json[name] = value.toJSON();
+          } else {
+            _ref = this.nested_attributes;
+            for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+              attribute = _ref[_i];
+              if (attribute === name) {
+                json["" + name + "_attributes"] = value.json();
+              }
+            }
+          }
+        } else {
+          json[name] = value;
+        }
+      }
+      observable.unobserve(json);
+      delete json.dirty;
+      delete json.resource;
+      delete json.route;
+      delete json.initial_route;
+      delete json.after_initialize;
+      delete json.parent_resource;
+      delete json.nested_attributes;
+      delete json.on_save;
+      delete json.element;
+      delete json["default"];
+      delete json.lock;
+      delete json.validated;
+      return json;
+    }
+  }
+};
+
+restful.toJSON = restful.json;
+
+model = window.model;
+
+record = window.record;
+
+model.restfulable = true;
+
+record.mix(function(recordable) {
+  return merge(recordable, restful.record);
+});
+
+model.mix(function(modelable) {
+  return merge(modelable, restful.model);
+});
+
+model.associable && model.associable.mix(function(singular_association, plural_association) {
+  plural_association.get = function() {
+    if (this.parent != null) {
+      this.route || (this.route = "" + this.parent.route + "/" + this.parent._id + "/" + (model.pluralize(this.resource.name)));
+    }
+    return rest.get.apply(this, arguments);
+  };
+  return plural_association.post = function() {
+    if (this.parent != null) {
+      this.route || (this.route = "" + this.parent.route + "/" + this.parent._id + "/" + (model.pluralize(this.resource.name)));
+    }
+    return rest.post.apply(this, arguments);
+  };
+});