ende 0.1.5 → 0.1.6

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

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

@@ -0,0 +1,71 @@
+var composed, remoteable, rest, root, stampit, validations;
+
+root = typeof exports !== "undefined" && exports !== null ? exports : window;
+
+validations = require('../validatable');
+
+rest = require('../rest');
+
+stampit = require('../../../vendor/stampit');
+
+remoteable = stampit({
+  validate_each: function(record, attribute, value) {
+    var data,
+      _this = this;
+
+    data = this.json(record);
+    return this.post(data).done(function(json) {
+      return _this.succeeded(json, record);
+    });
+  },
+  json: function(record) {
+    var data, _base;
+
+    data = {};
+    data[this.resource] = record.json();
+    (_base = data[this.resource]).id || (_base.id = data[this.resource]._id);
+    delete data[this.resource]._id;
+    return data;
+  },
+  post: function(data) {
+    return jQuery.ajax({
+      url: this.route,
+      data: data,
+      type: 'post',
+      dataType: 'json',
+      context: this
+    });
+  },
+  succeeded: function(json, record) {
+    var error_message, error_messages, _i, _len, _results;
+
+    error_messages = json[this.attribute_name];
+    if (!error_messages) {
+      return;
+    }
+    _results = [];
+    for (_i = 0, _len = error_messages.length; _i < _len; _i++) {
+      error_message = error_messages[_i];
+      _results.push(record.errors.add(this.attribute_name, 'server', {
+        server_message: error_message
+      }));
+    }
+    return _results;
+  }
+}, {
+  message: "Remote validation failed",
+  route: null
+}, function() {
+  var pluralized_resource;
+
+  pluralized_resource = model.pluralize(this.model.resource);
+  this.resource = this.model.resource;
+  this.route || (this.route = "/" + pluralized_resource + "/validate");
+  return this;
+});
+
+composed = stampit.compose(validations.validatable, remoteable);
+
+composed.definition_key = 'validates_remotely';
+
+validations.manager.validators.remote = composed;

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

@@ -0,0 +1,167 @@
+var $, advisable, bind, extend, merge, observable, type,
+  __slice = [].slice;
+
+$ = require('jquery');
+
+type = require('type');
+
+bind = require('bind');
+
+observable = require('observable').mixin;
+
+advisable = require('advisable').mixin;
+
+extend = require('assimilate');
+
+merge = require('assimilate').withStrategy('deep');
+
+this.model = (function() {
+  var initialize_record, mixer, modelable;
+
+  modelable = {
+    after_mix: [],
+    record: {
+      after_initialize: []
+    },
+    all: function() {
+      return this.cache;
+    },
+    create: function() {
+      var params;
+
+      params = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+      throw 'model.create not implemented yet, try using the restful.model.create method';
+    },
+    find: function(id) {
+      return this.where({
+        id: id
+      }, true);
+    },
+    where: function(conditions, first) {
+      var record, results, _i, _len, _ref;
+
+      if (first == null) {
+        first = false;
+      }
+      results = [];
+      if (type(conditions.id) !== 'array') {
+        conditions.id = [conditions.id];
+      }
+      _ref = this.cache;
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        record = _ref[_i];
+        if (conditions.id.indexOf(record._id) !== -1) {
+          if (first) {
+            return record;
+          } else {
+            results.push(record);
+          }
+        }
+      }
+      if (first) {
+        return null;
+      } else {
+        return results;
+      }
+    }
+  };
+  initialize_record = function(data) {
+    var after_initialize, callback, instance, _i, _len, _ref;
+
+    if (data == null) {
+      data = {
+        resource: this.resource,
+        parent_resource: this.parent_resource
+      };
+    }
+    data.resource || (data.resource = this.resource);
+    data.parent_resource || (data.parent_resource = this.resource.parent || this.parent_resource);
+    data.route || (data.route = this.route);
+    data.nested_attributes = this.nested_attributes || [];
+    after_initialize = (data.after_initialize || []).concat(this.record.after_initialize);
+    instance = record.call(extend(Object.create(data), this.record, {
+      after_initialize: after_initialize
+    }));
+    _ref = instance.after_initialize;
+    for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+      callback = _ref[_i];
+      callback.call(instance, instance);
+    }
+    delete instance.after_initialize;
+    return instance;
+  };
+  mixer = function(options) {
+    var after_initialize, callback, instance, _i, _len, _ref;
+
+    if (this === window) {
+      throw 'Model mixin called incorrectly call with model.call {} instead of model({})';
+    }
+    if (!mixer.stale) {
+      mixer.stale = true;
+    }
+    if (this.record && this.record.after_initialize) {
+      after_initialize = this.record.after_initialize.splice(0);
+    } else {
+      after_initialize = [];
+    }
+    instance = bind(this, initialize_record);
+    extend(instance, merge(this, modelable));
+    this.record = instance.record = merge({}, instance.record, modelable.record);
+    this.record.after_initialize = instance.record.after_initialize = instance.record.after_initialize.concat(after_initialize);
+    _ref = modelable.after_mix;
+    for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+      callback = _ref[_i];
+      callback.call(instance, instance);
+    }
+    return mixer[this.resource.name || this.resource.toString()] = instance;
+  };
+  mixer.mix = function(blender) {
+    if (this.stale) {
+      throw "Trying to change model mixin with " + object + " but model already used.\nCheck your configuration order";
+    }
+    return blender(modelable);
+  };
+  return mixer;
+})();
+
+this.record = (function() {
+  var callbacks, recordable, that;
+
+  callbacks = {
+    dirtify: function() {
+      return this.subscribe(function(prop, value, old) {
+        if (prop !== 'dirty' && !this.dirty && value !== old) {
+          console.groupCollapsed("◉ Property '" + prop + "' dirtied a " + this.resource);
+          console.log(old, "→", value);
+          console.log(this);
+          console.groupEnd();
+          return this.dirty = true;
+        }
+      });
+    }
+  };
+  recordable = {
+    dirty: false,
+    after_initialize: [callbacks.dirtify]
+  };
+  that = function(data) {
+    var after_initialize;
+
+    if (this === window) {
+      throw "Mixin called incorrectly, call mixin with call method: record.call(object, data)";
+    }
+    data || (data = {});
+    after_initialize = (this.after_initialize || []).concat(data.after_initialize || []).concat(recordable.after_initialize);
+    return advisable(observable(extend(this, recordable, data, {
+      after_initialize: after_initialize
+    })));
+  };
+  that.mix = function(blender) {
+    return blender(recordable);
+  };
+  return that;
+})();
+
+exports.record = this.record;
+
+exports.model = this.model;