ende 0.1.4 → 0.1.5

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

@@ -0,0 +1,279 @@
+var $, builders, defaults, extend, merge, model, record, rest, scopable, stampit,
+  __slice = [].slice;
+
+require('./restfulable');
+
+require('./resource');
+
+stampit = require('../../vendor/stampit');
+
+extend = require('assimilate');
+
+merge = extend.withStrategy('deep');
+
+$ = require('jquery');
+
+rest = require('./rest');
+
+scopable = {
+  builder: stampit().enclose(function() {
+    return stampit.mixIn(function(name, type) {
+      var builder;
+
+      if ($.type(type) === 'function') {
+        this["$" + name] = type() || new type;
+        type = $.type(this["$" + name]);
+      } else {
+        this["$" + name] = defaults[type] || type;
+      }
+      if ($.type(type) !== 'string') {
+        type = $.type(type);
+      }
+      builder = builders[type];
+      if (builder == null) {
+        throw "Unknown scope type " + type + " for model with resource " + model.resource;
+      }
+      this.scope.declared.push(name);
+      return this[name] = builder({
+        name: name
+      });
+    }, {
+      data: {},
+      then: [],
+      fail: [],
+      declared: [],
+      fetch: function(data, done, fail) {
+        var promise, scope;
+
+        scope = extend({}, this.scope.data);
+        promise = rest.get.call(this, extend(scope, data)).done(this.scope.then.concat(done)).fail([this.scope.fail, fail]);
+        this.scope.clear();
+        return promise;
+      },
+      clear: function() {
+        this.data = {};
+        return this.callbacks = [];
+      }
+    });
+  }),
+  base: stampit().state({
+    name: 'unamed_scope'
+  }),
+  record: {
+    failed: function(xhr, error, status) {
+      var e, message, payload;
+
+      payload = xhr.responseJSON;
+      try {
+        payload || (payload = JSON.parse(xhr.responseText));
+      } catch (_error) {
+        e = _error;
+      }
+      payload || (payload = xhr.responseText);
+      switch (xhr.status) {
+        case 422:
+          this.valid = false;
+          return this.errors = payload.errors;
+        default:
+          message = "Fail in " + this.resource + ".save:\n";
+          message += "Record: " + this + "\n";
+          message += "Status: " + status + " (" + (payload.status || xhr.status) + ")\n";
+          message += "Error : " + (payload.error || payload.message || payload);
+      }
+      return console.error(message);
+    }
+  },
+  model: {
+    fetch: function(data, done, fail) {
+      return this.scope.fetch.call(this, data, done, fail);
+    },
+    forward_scopes_to_associations: function() {
+      var associated_factory, associated_resource, association, association_name, factory, forwarder, generate_forwarder, scope, _i, _j, _k, _l, _len, _len1, _len2, _len3, _len4, _m, _ref, _ref1, _ref2, _ref3, _ref4;
+
+      factory = model[this.resource];
+      _ref = factory.has_many;
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        association_name = _ref[_i];
+        associated_resource = model.singularize(association_name);
+        associated_factory = model[associated_resource];
+        if (!model[associated_resource]) {
+          console.warn("Associated factory not found for associated resource: " + associated_resource);
+          continue;
+        }
+        association = this[association_name];
+        association.scope = scopable.builder(association);
+        _ref1 = associated_factory.scope.declared;
+        for (_j = 0, _len1 = _ref1.length; _j < _len1; _j++) {
+          scope = _ref1[_j];
+          association.scope(scope, associated_factory["$" + scope]);
+        }
+      }
+      _ref2 = factory.has_one;
+      for (_k = 0, _len2 = _ref2.length; _k < _len2; _k++) {
+        associated_resource = _ref2[_k];
+        if (!model[associated_resource]) {
+          console.warn("Associated factory not found for associated resource: " + associated_resource);
+          continue;
+        }
+        _ref3 = model[associated_resource].scope.declared;
+        for (_l = 0, _len3 = _ref3.length; _l < _len3; _l++) {
+          scope = _ref3[_l];
+          this[associated_resource][scope] = factory[scope];
+        }
+      }
+      if (factory.belongs_to.length) {
+        generate_forwarder = function(associated_resource) {
+          var declared_scopes;
+
+          associated_factory = model[associated_resource];
+          if (!associated_factory) {
+            return console.warn("Associated factory not found for associated resource: " + associated_resource);
+          }
+          declared_scopes = associated_factory.scope.declared;
+          return function() {
+            var _len4, _m, _results;
+
+            _results = [];
+            for (_m = 0, _len4 = declared_scopes.length; _m < _len4; _m++) {
+              scope = declared_scopes[_m];
+              _results.push(this[associated_resource][scope] = associated_factory[scope]);
+            }
+            return _results;
+          };
+        };
+        _ref4 = factory.belongs_to;
+        for (_m = 0, _len4 = _ref4.length; _m < _len4; _m++) {
+          associated_resource = _ref4[_m];
+          forwarder = generate_forwarder(associated_resource);
+          this.after("build_" + associated_resource, forwarder);
+        }
+      }
+      return true;
+    }
+  },
+  after_mix: function() {
+    var name, property, type, _results;
+
+    this.scope = scopable.builder(this);
+    _results = [];
+    for (property in this) {
+      type = this[property];
+      if (property.charAt(0) === '$') {
+        name = property.substring(1);
+        _results.push(this.scope(name, type));
+      } else {
+        _results.push(void 0);
+      }
+    }
+    return _results;
+  }
+};
+
+builders = {
+  boolean: stampit().enclose(function() {
+    var base;
+
+    base = scopable.base(this);
+    return stampit.mixIn(function() {
+      var callbacks, value, _base, _name;
+
+      value = arguments[0], callbacks = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+      callbacks.length && (this.scope.then = this.scope.then.concat(callbacks));
+      (_base = this.scope.data)[_name = base.name] || (_base[_name] = value != null ? value : this["$" + base.name]);
+      return this;
+    });
+  }),
+  array: stampit().enclose(function() {
+    var base;
+
+    base = scopable.base(this);
+    return stampit.mixIn(function() {
+      var values, _base, _name;
+
+      values = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+      (_base = this.scope.data)[_name = base.name] || (_base[_name] = values != null ? values : this["$" + base.name]);
+      return this;
+    });
+  })
+};
+
+defaults = {
+  boolean: true,
+  array: []
+};
+
+model = window.model;
+
+record = window.record;
+
+model.scopable = true;
+
+model.mix(function(modelable) {
+  merge(modelable, scopable.model);
+  return modelable.after_mix.push(scopable.after_mix);
+});
+
+if (model.associable) {
+  model.mix(function(modelable) {
+    return modelable.record.after_initialize.push(function() {
+      return scopable.model.forward_scopes_to_associations.call(this);
+    });
+  });
+  model.associable.mix(function(singular_association, plural_association) {
+    plural_association.all = plural_association.reload = function(data, done, fail) {
+      var promises, reload;
+
+      if (this.parent != null) {
+        this.route || (this.route = "" + this.parent.route + "/" + this.parent._id + "/" + (model.pluralize(this.resource)));
+      }
+      promises = [];
+      if (typeof data === 'function') {
+        done = data;
+        data = void 0;
+      }
+      promises.push(this.scope.fetch.call(this, data, null, scopable.record.failed));
+      reload = $.when.apply(jQuery, promises);
+      reload.done(function(records, status) {
+        var association_name, singular_resource, _i, _j, _len, _len1, _ref;
+
+        Array.prototype.splice.call(this, 0);
+        if (!records.length) {
+          return;
+        }
+        singular_resource = model.singularize(this.resource);
+        for (_i = 0, _len = records.length; _i < _len; _i++) {
+          record = records[_i];
+          _ref = model[singular_resource].has_many;
+          for (_j = 0, _len1 = _ref.length; _j < _len1; _j++) {
+            association_name = _ref[_j];
+            record["" + association_name + "_attributes"] = record[association_name];
+            delete record[association_name];
+          }
+        }
+        this.add.apply(this, records);
+        records.splice(0);
+        return records.push.apply(records, this);
+      });
+      reload.done(done);
+      reload.fail(fail);
+      return reload;
+    };
+    return plural_association.each = function(callback) {
+      var _this = this;
+
+      if (this.parent != null) {
+        this.route || (this.route = "" + this.parent.route + "/" + this.parent._id + "/" + (model.pluralize(this.resource)));
+      }
+      return this.get().done(function(records) {
+        var _i, _len, _results;
+
+        _results = [];
+        for (_i = 0, _len = _this.length; _i < _len; _i++) {
+          record = _this[_i];
+          _results.push(callback(record));
+        }
+        return _results;
+      });
+    };
+  });
+}

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

@@ -0,0 +1,19 @@
+var extend, extensions, root;
+
+root = typeof exports !== "undefined" && exports !== null ? exports : window;
+
+extend = require('assimilate');
+
+extensions = {
+  model: {
+    human_attribute_name: function(attribute_name) {
+      var _ref, _ref1;
+
+      return ((_ref = this.translation) != null ? (_ref1 = _ref.attributes) != null ? _ref1[attribute_name] : void 0 : void 0) || attribute_name;
+    }
+  }
+};
+
+model.mix(function(modelable) {
+  return extend(modelable, extensions.model);
+});

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

@@ -0,0 +1,216 @@
+var errorsable, extensions, initializers, manager, messages, observable, root, stampit, type, validatable;
+
+require('./translationable');
+
+root = typeof exports !== "undefined" && exports !== null ? exports : window;
+
+stampit = require('../../vendor/stampit');
+
+observable = require('observable').mixin;
+
+type = require('type');
+
+messages = {
+  blank: function(attribute_name) {
+    attribute_name = this.human_attribute_name(attribute_name);
+    return "O campo " + attribute_name + " não pode ficar em branco.";
+  },
+  cpf: function(attribute_name) {
+    attribute_name = this.human_attribute_name(attribute_name);
+    return "O campo " + attribute_name + " não está válido.";
+  },
+  confirmation: function(attribute_name) {
+    var confirmation_attribute_name;
+
+    confirmation_attribute_name = this.human_attribute_name("" + attribute_name + "_confirmation");
+    attribute_name = this.human_attribute_name(attribute_name);
+    return "O campo " + attribute_name + " não está diacordo com a confirmação " + confirmation_attribute_name + ".";
+  },
+  associated: function(attribute_name) {
+    attribute_name = this.human_attribute_name(attribute_name);
+    return "O registro associado " + attribute_name + " não é válido";
+  },
+  server: function(attribute_name, options) {
+    return "" + (this.human_attribute_name(attribute_name)) + " " + options.server_message + " ";
+  }
+};
+
+errorsable = stampit({
+  add: function(attribute_name, message_key, options) {
+    var translator;
+
+    this.push([attribute_name, message_key, options]);
+    this.messages[attribute_name] = '';
+    translator = messages[message_key];
+    if (translator != null) {
+      return this.messages[attribute_name] += translator.call(this.model, attribute_name, options);
+    } else {
+      return this.messages[attribute_name] += message_key;
+    }
+  },
+  clear: function() {
+    var attribute_name, _results;
+
+    if (this.length) {
+      this.length = 0;
+      _results = [];
+      for (attribute_name in this.messages) {
+        _results.push(this.messages[attribute_name] = null);
+      }
+      return _results;
+    }
+  },
+  push: Array.prototype.push,
+  splice: Array.prototype.splice
+}, {
+  model: null,
+  messages: {},
+  length: 0
+});
+
+initializers = {
+  define_triggers: function() {
+    this.errors = errorsable({
+      model: model[this.resource]
+    });
+    this.before('save', function() {
+      if (this.save) {
+        return this.validate();
+      }
+    });
+    this.validated = false;
+    this.subscribe('dirty', function() {
+      return this.validated = false;
+    });
+    return Object.defineProperty(this, 'valid', {
+      get: function() {
+        this.validate();
+        if (this.validation.state() === 'resolved') {
+          return !this.errors.length;
+        } else {
+          return null;
+        }
+      },
+      set: function() {
+        throw new TypeError("You can't set the value for the valid property.");
+      },
+      enumerable: false
+    });
+  },
+  create_validators: function(definitions) {
+    var definition, name, validator, validator_options, _ref, _results;
+
+    _ref = manager.validators;
+    _results = [];
+    for (name in _ref) {
+      validator = _ref[name];
+      definition = definitions[validator.definition_key];
+      if (definition) {
+        if (type(definition) !== 'array') {
+          definition = [definition];
+        }
+        _results.push((function() {
+          var _i, _len, _results1;
+
+          _results1 = [];
+          for (_i = 0, _len = definition.length; _i < _len; _i++) {
+            validator_options = definition[_i];
+            if (type(validator_options) !== 'object') {
+              validator_options = {
+                attribute_name: validator_options
+              };
+            }
+            validator_options.model = this;
+            this.validators.push(validator(validator_options));
+            _results1.push(delete definitions[validator.definition_key]);
+          }
+          return _results1;
+        }).call(this));
+      } else {
+        _results.push(void 0);
+      }
+    }
+    return _results;
+  }
+};
+
+extensions = {
+  model: {
+    validators: []
+  },
+  record: {
+    validate_attribute: function(attribute, doned, failed) {
+      var results, validation, validator, _i, _len, _ref;
+
+      this.errors.messages[attribute] = null;
+      results = [this, attribute];
+      _ref = model[this.resource].validators;
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        validator = _ref[_i];
+        if (validator.attribute_name === attribute) {
+          results.push(validator.validate_each(this, validator.attribute_name, this[validator.attribute_name]));
+        }
+      }
+      validation = jQuery.when.apply(jQuery, results);
+      validation.done(doned);
+      validation.fail(failed);
+      return validation;
+    },
+    validate: function(doned, failed) {
+      var results, validator, _i, _len, _ref;
+
+      if (this.validated) {
+        return this.validation;
+      }
+      this.errors.clear();
+      results = [this];
+      _ref = model[this.resource].validators;
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        validator = _ref[_i];
+        results.push(validator.validate_each(this, validator.attribute_name, this[validator.attribute_name]));
+      }
+      this.validation = jQuery.when.apply(jQuery, results);
+      this.validation.done(doned);
+      this.validation.fail(failed);
+      this.validation.then(function(record) {
+        return record.validated = true;
+      });
+      return this.validation;
+    }
+  }
+};
+
+manager = {
+  validators: {}
+};
+
+validatable = stampit({
+  validate: function() {
+    throw new Error('Composed factory must override the validate method');
+  },
+  validate_each: function() {
+    throw new Error('Composed factory must override the validate each method');
+  }
+});
+
+model.mix(function(modelable) {
+  jQuery.extend(modelable, extensions.model);
+  jQuery.extend(modelable.record, extensions.record);
+  modelable.after_mix.unshift(initializers.create_validators);
+  modelable.record.after_initialize.push(initializers.define_triggers);
+  return model.validators = manager.validators;
+});
+
+root.validatable = validatable;
+
+root.manager = manager;
+
+require('./validations/confirmation');
+
+require('./validations/associated');
+
+require('./validations/presence');
+
+require('./validations/remote');
+
+require('./validations/cpf');

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

@@ -0,0 +1,30 @@
+var associationable, composed, stampit, validations;
+
+validations = require('../validatable');
+
+stampit = require('../../../vendor/stampit');
+
+associationable = stampit({
+  validate_each: function(record, attribute, value) {
+    var associated_validation;
+
+    if (record[attribute]) {
+      if (model[record.resource].has_one.indexOf(attribute) === -1) {
+        throw new Error('Only has_one associations are supported to validates_associated');
+      }
+      associated_validation = record[attribute].validate();
+      associated_validation.done(function() {
+        if (record[attribute].errors.length) {
+          return record.errors.add(attribute, 'associated', this.options);
+        }
+      });
+      return associated_validation;
+    }
+  }
+});
+
+composed = stampit.compose(validations.validatable, associationable);
+
+composed.definition_key = 'validates_associated';
+
+validations.manager.validators.association = composed;

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

@@ -0,0 +1,19 @@
+var composed, confirmationable, stampit, validations;
+
+validations = require('../validatable');
+
+stampit = require('../../../vendor/stampit');
+
+confirmationable = stampit({
+  validate_each: function(record, attribute, value) {
+    if (record[attribute] !== record["" + attribute + "_confirmation"]) {
+      return record.errors.add(attribute, 'confirmation', this.options);
+    }
+  }
+});
+
+composed = stampit.compose(validations.validatable, confirmationable);
+
+composed.definition_key = 'validates_confirmation_of';
+
+validations.manager.validators.confirmation = composed;

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

@@ -0,0 +1,60 @@
+var composed, cpfable, stampit, validations;
+
+validations = require('../validatable');
+
+stampit = require('../../../vendor/stampit');
+
+cpfable = stampit({
+  validate_format: function(value) {
+    var c, d1, dv, i, v, _i, _j;
+
+    value = value.replace(/[\.\-]/g, "");
+    if (value.length < 11) {
+      return false;
+    }
+    if (value.match(/^(0+|1+|2+|3+|4+|5+|6+|7+|8+|9+)$/)) {
+      return false;
+    }
+    c = value.substr(0, 9);
+    dv = value.substr(9, 2);
+    d1 = 0;
+    v = false;
+    i = 0;
+    for (i = _i = 1; _i <= 9; i = ++_i) {
+      d1 += c.charAt(i) * (10 - i);
+    }
+    if (d1 === 0) {
+      return false;
+    }
+    d1 = 11 - (d1 % 11);
+    if (d1 > 9) {
+      d1 = 0;
+    }
+    if (+dv.charAt(0 !== d1)) {
+      return false;
+    }
+    d1 *= 2;
+    for (i = _j = 1; _j <= 9; i = ++_j) {
+      d1 += c.charAt(i) * (11 - i);
+    }
+    d1 = 11 - (d1 % 11);
+    if (d1 > 9) {
+      d1 = 0;
+    }
+    if (+dv.charAt(1) !== d1) {
+      return false;
+    }
+    return true;
+  },
+  validate_each: function(record, attribute, value) {
+    if (value && !this.validate_format(value)) {
+      return record.errors.add(attribute, 'cpf', this.options);
+    }
+  }
+});
+
+composed = stampit.compose(validations.validatable, cpfable);
+
+composed.definition_key = 'validates_cpf_format';
+
+validations.manager.validators.cpf = composed;

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

@@ -0,0 +1,19 @@
+var composed, presenceable, stampit, validations;
+
+validations = require('../validatable');
+
+stampit = require('../../../vendor/stampit');
+
+presenceable = stampit({
+  validate_each: function(record, attribute, value) {
+    if (value === null || value === '' || value === void 0) {
+      return record.errors.add(attribute, 'blank', this.options);
+    }
+  }
+});
+
+composed = stampit.compose(validations.validatable, presenceable);
+
+composed.definition_key = 'validates_presence_of';
+
+validations.manager.validators.presence = composed;