ende 0.1.5 → 0.1.6

data/vendor/components/discore-closest/component.json

@@ -0,0 +1,14 @@
+{
+  "name": "closest",
+  "description": "Find the closest ancestor matching a selector string",
+  "version": "0.1.0",
+  "repo": "discore/closest",
+  "dependencies": {
+    "component/matches-selector": "*"
+  },
+  "main": "index.js",
+  "scripts": [
+    "index.js"
+  ],
+  "license": "MIT"
+}

data/vendor/components/discore-closest/index.js

@@ -0,0 +1,18 @@
+var matches = require('matches-selector')
+
+module.exports = function (element, selector, checkYoSelf, root) {
+  element = checkYoSelf ? element : element.parentNode
+  root = root || document
+
+  do {
+    if (matches(element, selector))
+      return element
+    // After `matches` on the edge case that
+    // the selector matches the root
+    // (when the root is not the document)
+    if (element === root)
+      return
+    // Make sure `element !== document`
+    // otherwise we get an illegal invocation
+  } while ((element = element.parentNode) && element !== document)
+}

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

@@ -0,0 +1,21 @@
+{
+  "name": "advisable",
+  "repo": "indefinido/advisable",
+  "description": "Aspect oriented programming mixin",
+  "version": "0.0.1",
+  "keywords": [
+    "aspect",
+    "aop",
+    "mixin"
+  ],
+  "dependencies": {
+    "component/jquery": "*"
+  },
+  "development": {},
+  "license": "WTFP",
+  "paths": [],
+  "scripts": [
+    "index.js",
+    "lib/advisable.js"
+  ]
+}

data/vendor/components/indefinido-advisable/index.js

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

data/vendor/components/indefinido-advisable/lib/advisable.js

@@ -0,0 +1,60 @@
+var $, advice, mixin;
+
+$ = require('jquery');
+
+advice = {
+  around: function(base, wrapped) {
+    return function() {
+      var args;
+
+      args = $.makeArray(arguments);
+      return wrapped.apply(this, [$.proxy(base, this)].concat(args));
+    };
+  },
+  before: function(base, before) {
+    return this.around(base, function() {
+      var args, orig;
+
+      args = $.makeArray(arguments);
+      orig = args.shift();
+      before.apply(this, args);
+      return orig.apply(this, args);
+    });
+  },
+  after: function(base, after) {
+    return this.around(base, function() {
+      var args, orig, res;
+
+      args = $.makeArray(arguments);
+      orig = args.shift();
+      res = orig.apply(this, args);
+      after.apply(this, args);
+      return res;
+    });
+  }
+};
+
+mixin = {
+  before: function(method, advicer) {
+    if (typeof this[method] === 'function') {
+      return this[method] = advice.before(this[method], advicer);
+    }
+    throw new TypeError("Can only advice functions, attribute " + method + " of " + this + " is of type " + (typeof this[method]));
+  },
+  after: function(method, advicer) {
+    if (typeof this[method] === 'function') {
+      return this[method] = advice.after(this[method], advicer);
+    }
+    throw new TypeError("Can only advice functions, attribute " + method + " of " + this + " is of type " + (typeof this[method]));
+  },
+  around: function(method, advicer) {
+    if (typeof this[method] === 'function') {
+      return this[method] = advice.around(this[method], advicer);
+    }
+    throw new TypeError("Can only advice functions, attribute " + method + " of " + this + " is of type " + (typeof this[method]));
+  }
+};
+
+exports.mixin = function(object) {
+  return $.extend(object, mixin);
+};

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

@@ -0,0 +1,40 @@
+{
+  "name": "indemma",
+  "repo": "indefinido/indemma",
+  "description": "Indemma (mind picture = memory), client side ES5 observable REST model",
+  "version": "0.0.2",
+  "keywords": [],
+  "dependencies": {
+    "pluma/assimilate": "*",
+    "component/type": "*",
+    "component/bind": "*",
+    "component/jquery": "*",
+    "indefinido/observable": "*",
+    "indefinido/advisable": "*",
+    "chaijs/chai": "*"
+  },
+  "development": {
+    "chaijs/chai": "*"
+  },
+  "license": "WTFPL",
+  "scripts": [
+    "index.js",
+    "vendor/stampit.js",
+    "vendor/sinon.js",
+    "lib/record.js",
+    "lib/record/associable.js",
+    "lib/record/resource.js",
+    "lib/record/rest.js",
+    "lib/record/restfulable.js",
+    "lib/record/scopable.js",
+    "lib/record/maid.js",
+    "lib/record/translationable.js",
+    "lib/record/validations/remote.js",
+    "lib/record/validations/presence.js",
+    "lib/record/validations/confirmation.js",
+    "lib/record/validations/associated.js",
+    "lib/record/validations/cpf.js",
+    "lib/record/validatable.js",
+    "lib/extensions/rivets.js"
+  ]
+}

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

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

data/vendor/components/indefinido-indemma/lib/extensions/rivets.js

@@ -0,0 +1,23 @@
+var root;
+
+root = typeof exports !== "undefined" && exports !== null ? exports : this;
+
+model.rivets = function() {
+  var model_extensions;
+
+  model_extensions = {
+    record: {
+      tie: function(element) {
+        var lasso;
+
+        lasso = {};
+        lasso[this.resource] = this;
+        return rivets.bind(element, lasso);
+      }
+    },
+    preloadData: true
+  };
+  return model.mix(function(modelable) {
+    return $.extend(true, modelable, model_extensions);
+  });
+};

data/vendor/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/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/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/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
+  });
+};