ende 0.1.14 → 0.2.0

data/vendor/components/indefinido-indemma/components/indefinido-observable/vendor/shims/object.create.js

@@ -0,0 +1,77 @@
+// ES5 15.2.3.5
+// http://es5.github.com/#x15.2.3.5
+if (!Object.create) {
+
+    // Contributed by Brandon Benvie, October, 2012
+    var createEmpty;
+    var supportsProto = Object.prototype.__proto__ === null;
+    if (supportsProto || typeof document == 'undefined') {
+        createEmpty = function () {
+            return { "__proto__": null };
+        };
+    } else {
+        // In old IE __proto__ can't be used to manually set `null`, nor does
+        // any other method exist to make an object that inherits from nothing,
+        // aside from Object.prototype itself. Instead, create a new global
+        // object and *steal* its Object.prototype and strip it bare. This is
+        // used as the prototype to create nullary objects.
+        createEmpty = function () {
+            var iframe = document.createElement('iframe');
+            var parent = document.body || document.documentElement;
+            iframe.style.display = 'none';
+            parent.appendChild(iframe);
+            iframe.src = 'javascript:';
+            var empty = iframe.contentWindow.Object.prototype;
+            parent.removeChild(iframe);
+            iframe = null;
+            delete empty.constructor;
+            delete empty.hasOwnProperty;
+            delete empty.propertyIsEnumerable;
+            delete empty.isPrototypeOf;
+            delete empty.toLocaleString;
+            delete empty.toString;
+            delete empty.valueOf;
+            empty.__proto__ = null;
+
+            function Empty() {}
+            Empty.prototype = empty;
+            // short-circuit future calls
+            createEmpty = function () {
+                return new Empty();
+            };
+            return new Empty();
+        };
+    }
+
+    Object.create = function create(prototype, properties) {
+
+        var object;
+        function Type() {}  // An empty constructor.
+
+        if (prototype === null) {
+            object = createEmpty();
+        } else {
+            if (typeof prototype !== "object" && typeof prototype !== "function") {
+                // In the native implementation `parent` can be `null`
+                // OR *any* `instanceof Object`  (Object|Function|Array|RegExp|etc)
+                // Use `typeof` tho, b/c in old IE, DOM elements are not `instanceof Object`
+                // like they are in modern browsers. Using `Object.create` on DOM elements
+                // is...err...probably inappropriate, but the native version allows for it.
+                throw new TypeError("Object prototype may only be an Object or null"); // same msg as Chrome
+            }
+            Type.prototype = prototype;
+            object = new Type();
+            // IE has no built-in implementation of `Object.getPrototypeOf`
+            // neither `__proto__`, but this manually setting `__proto__` will
+            // guarantee that `Object.getPrototypeOf` will work as expected with
+            // objects created using `Object.create`
+            object.__proto__ = prototype;
+        }
+
+        if (properties !== void 0) {
+            Object.defineProperties(object, properties);
+        }
+
+        return object;
+    };
+}

data/vendor/components/indefinido-indemma/components/kapit-observe-utils/component.json

@@ -0,0 +1,13 @@
+{
+  "name": "observe-utils",
+  "version": "0.1.0",
+  "main": "lib/observe-utils.js",
+  "devDependencies": {
+    "expect": "~0.2.0",
+    "sinon": "http://sinonjs.org/releases/sinon-1.6.0.js",
+    "observe-shim": "https://github.com/KapIT/observe-shim.git",
+    "mocha": "~1.8.1",
+    "es5-shim": "~2.0.8"
+  },
+  "repo": "https://raw.github.com/kapit/observe-utils"
+}

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

@@ -0,0 +1,25 @@
+{
+  "name": "assimilate",
+  "version": "0.2.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,87 @@
+/*! assimilate 0.2.0 Copyright (c) 2013 Alan Plum. MIT licensed. */
+var slice = Array.prototype.slice;
+
+function assimilateWithStrategy(strategy, copyInherited, target) {
+    var sources = slice.call(arguments, 3),
+        i, source, key;
+
+    if (target === undefined || target === null) {
+        target = {};
+    }
+
+    for (i = 0; i < sources.length; i++) {
+        source = sources[i];
+        if (source === undefined || source === null) continue;
+        for (key in source) {
+            if (copyInherited || source.hasOwnProperty(key)) {
+                strategy(target, source, key, copyInherited);
+            }
+        }
+    }
+
+    return target;
+}
+
+function assimilate() {
+    var args = slice.call(arguments, 0);
+    return assimilateWithStrategy.apply(
+        this, [assimilate.strategies.DEFAULT, false].concat(args)
+    );
+}
+
+assimilate.withStrategy = function(strategy, copyInherited) {
+    if (arguments.length === 1 && typeof strategy === 'boolean') {
+        copyInherited = strategy;
+        strategy = 'default';
+    }
+    if (typeof strategy === 'string') {
+        strategy = strategy.toUpperCase();
+        if (typeof assimilate.strategies[strategy] === 'function') {
+            strategy = assimilate.strategies[strategy];
+        }
+    }
+    if (typeof strategy !== 'function') {
+        throw new Error('Unknown strategy or not a function: ' + strategy);
+    }
+    return function() {
+        var args = slice.call(arguments, 0);
+        return assimilateWithStrategy.apply(
+            this, [strategy, !!copyInherited].concat(args)
+        );
+    };
+};
+
+assimilate.strategies = {
+    DEFAULT: function(target, source, key) {
+        target[key] = source[key];
+    },
+    DEEP: function(target, source, key, copyInherited) {
+        var newValue = source[key];
+        var oldValue = target[key];
+        if (
+            target.hasOwnProperty(key) &&
+            typeof newValue === 'object' &&
+            typeof oldValue === 'object'
+        ) {
+            assimilateWithStrategy(
+                assimilate.strategies.DEEP, copyInherited, oldValue, newValue
+            );
+        } else {
+            target[key] = newValue;
+        }
+    },
+    STRICT: function(target, source, key) {
+        var value = source[key];
+        if (value !== undefined) {
+            target[key] = value;
+        }
+    },
+    FALLBACK: function(target, source, key) {
+        var oldValue = target[key];
+        if (oldValue === undefined) {
+            target[key] = source[key];
+        }
+    }
+};
+
+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

@@ -50,13 +50,13 @@ plural = {
   },
   push: Array.prototype.push,
   length: 0,
-  json: function() {
+  json: function(methods, omissions) {
     var record, _i, _len, _results;
 
     _results = [];
     for (_i = 0, _len = this.length; _i < _len; _i++) {
       record = this[_i];
-      _results.push(record.json());
+      _results.push(record.json(methods, omissions));
     }
     return _results;
   }
@@ -109,21 +109,21 @@ associable = {
         update_association: function(data) {
           var associated, association, association_name, id, pluralized_association, _i, _j, _len, _len1, _ref;
 
-          id = this._id || data._id || data.id;
+          id = this._id || data && (data._id || data.id);
           if (!id) {
             return;
           }
-          _ref = model[this.resource].has_many;
+          _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)) + "/" + id + "/" + (model.pluralize(association.resource));
+              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)) + "/" + id + "/" + (model.pluralize(association.resource));
+                  associated.route = "/" + (model.pluralize(this.resource.toString())) + "/" + id + "/" + (model.pluralize(association.resource));
                 }
               }
             }

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

@@ -0,0 +1 @@
+

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

@@ -2,6 +2,8 @@ var model, resource, resourceable, stampit;
 
 stampit = require('../../vendor/stampit');
 
+require('../../vendor/owl/pluralize');
+
 resource = stampit({
   toString: function() {
     return this.name;
@@ -11,17 +13,25 @@ resource = stampit({
   scope: null,
   singular: false
 }, function() {
+  var _base;
+
+  if (this.original_reference) {
+    stampit.mixIn(this.original_reference, this);
+    this.original_reference.toString = this.toString;
+    (_base = this.original_reference).param_name || (_base.param_name = this.name);
+    return this.original_reference;
+  }
   this.param_name || (this.param_name = this.name);
   return this;
 });
 
 resourceable = {
-  pluralize: function(word) {
+  pluralize: function(word, count, plural) {
     if (!(word && word.length)) {
       throw new TypeError("Invalid string passed to pluralize '" + word + "'");
     }
     if (word.indexOf('s') !== word.length - 1) {
-      return word + 's';
+      return owl.pluralize(word, count, plural);
     } else {
       return word;
     }
@@ -30,7 +40,7 @@ resourceable = {
     if (!(word && word.length)) {
       throw new TypeError("Invalid string passed to singularize '" + word + "'");
     }
-    if (word.indexOf('s') === word.length - 1) {
+    if (word.lastIndexOf('s') === word.length - 1) {
       return word.substring(0, word.length - 1);
     } else {
       return word;
@@ -84,6 +94,7 @@ resourceable = {
       };
     }
     if (typeof this.resource === 'object') {
+      this.resource.original_reference = this.resource;
       resource_definition = this.resource;
     }
     resource_definition.parent = this.parent_resource;

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

@@ -7,10 +7,13 @@ module.exports = {
     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);
+    return request.call(this, 'put', (this._id ? "" + this.route + "/" + this._id : this.route), data);
   },
   post: function(data) {
     return request.call(this, 'post', this.route, data);
+  },
+  "delete": function(data) {
+    return request.call(this, 'delete', this.route, data);
   }
 };
 
@@ -22,9 +25,9 @@ request = function(method, url, data) {
     data = {};
     data[param_name] = this.json();
   }
-  if (data[param_name]) {
-    delete data[param_name]._id;
-    delete data[param_name].id;
+  if (data && data[param_name]) {
+    delete data[param_name]['id'];
+    delete data[param_name]['_id'];
   }
   return $.ajax({
     url: url,

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

@@ -29,7 +29,7 @@ util = {
 restful = {
   model: {
     create: function() {
-      var attributes, callback, params, record, _i, _j, _len, _results;
+      var attributes, callback, params, record, savings, _i, _j, _len;
 
       params = 2 <= arguments.length ? __slice.call(arguments, 0, _i = arguments.length - 1) : (_i = 0, []), callback = arguments[_i++];
       if (!arguments.length) {
@@ -37,18 +37,19 @@ restful = {
       }
       if (typeof callback !== 'function') {
         params.push(callback);
+        callback = void 0;
       }
       if (!params.length) {
         params.unshift({});
       }
-      _results = [];
+      savings = [];
       for (_j = 0, _len = params.length; _j < _len; _j++) {
         attributes = params[_j];
         record = this(attributes);
         record.dirty = true;
-        _results.push(record.save(callback));
+        savings.push(record.save(callback));
       }
-      return _results;
+      return $.when.apply($, savings);
     },
     all: function(conditions, callback) {
       if (conditions == null) {
@@ -92,7 +93,8 @@ restful = {
       promise = rest.get.call(this, data);
       route = old_route;
       return promise;
-    }
+    },
+    put: rest.put
   },
   record: {
     reload: function() {
@@ -159,20 +161,43 @@ restful = {
       }
       return _results;
     },
-    save: function(doned, failed, data) {
+    destroy: function(doned, failed, data) {
       var promise;
 
-      if (!this.dirty) {
-        return $.Deferred().resolve();
+      if (!((this.id != null) || (this._id != null))) {
+        throw new Error('Can\'t delete record without id!');
       }
-      promise = rest[this._id ? 'put' : 'post'].call(this, data);
-      promise.done(this.saved);
+      promise = rest["delete"].call(this, data);
+      promise.done(this.destroyed);
       promise.fail(this.failed);
       promise.done(doned);
       promise.fail(failed);
-      this.lock = JSON.stringify(this.json());
       return promise;
     },
+    saving: false,
+    salvation: null,
+    save: function(doned, failed, data) {
+      var salvation;
+
+      if (this.saving) {
+        return this.salvation;
+      }
+      this.lock = JSON.stringify(this.json());
+      if (!this.dirty) {
+        salvation = $.Deferred().resolveWith(this, null);
+      }
+      salvation || (salvation = rest[this._id ? 'put' : 'post'].call(this, data));
+      this.salvation = salvation;
+      this.saving = true;
+      salvation.done(this.saved);
+      salvation.fail(this.failed);
+      salvation.always(function() {
+        return this.saving = false;
+      });
+      salvation.done(doned);
+      salvation.fail(failed);
+      return salvation;
+    },
     saved: function(data) {
       var callback, _i, _len, _ref, _results;
 
@@ -248,9 +273,12 @@ restful = {
       serialized[this.resource] = this.json();
       return JSON.stringify(serialized);
     },
-    json: function() {
+    json: function(methods) {
       var attribute, json, name, value, _i, _len, _ref;
 
+      if (methods == null) {
+        methods = {};
+      }
       json = {};
       for (name in this) {
         value = this[name];
@@ -262,13 +290,13 @@ restful = {
         }
         if (type(value) === 'object') {
           if (value.toJSON != null) {
-            json[name] = value.toJSON();
+            json[name] = value.toJSON(methods[name]);
           } 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();
+                json["" + name + "_attributes"] = value.json(methods[name]);
               }
             }
           }
@@ -284,11 +312,13 @@ restful = {
       delete json.after_initialize;
       delete json.parent_resource;
       delete json.nested_attributes;
-      delete json.on_save;
+      delete json.saving;
+      delete json.salvation;
       delete json.element;
       delete json["default"];
       delete json.lock;
       delete json.validated;
+      delete json.validation;
       return json;
     }
   }

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

@@ -43,12 +43,18 @@ scopable = {
       fail: [],
       declared: [],
       fetch: function(data, done, fail) {
-        var promise, scope;
+        var deferred, 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]);
+        if (scope.noned != null) {
+          deferred = $.Deferred();
+          deferred.resolveWith(this, [[]]);
+        } else {
+          deferred = rest.get.call(this, extend(scope, data));
+        }
+        deferred.done(this.scope.then.concat(done)).fail([this.scope.fail, fail]);
         this.scope.clear();
-        return promise;
+        return deferred;
       },
       clear: function() {
         this.data = {};
@@ -84,6 +90,10 @@ scopable = {
     }
   },
   model: {
+    none: function() {
+      this.scope.data.noned = true;
+      return this;
+    },
     fetch: function(data, done, fail) {
       return this.scope.fetch.call(this, data, done, fail);
     },

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

@@ -22,16 +22,21 @@ messages = {
   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 + ".";
+    confirmation_attribute_name = this.human_attribute_name(attribute_name);
+    attribute_name = this.human_attribute_name(attribute_name.replace('_confirmation', ''));
+    return "O campo " + attribute_name + " não está de acordo com o campo " + 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";
+    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 + " ";
+    attribute_name = this.human_attribute_name(attribute_name);
+    return "" + attribute_name + " " + options.server_message + ".";
+  },
+  type: function(attribute_name, options) {
+    attribute_name = this.human_attribute_name(attribute_name);
+    return "O campo " + attribute_name + " não está válido.";
   }
 };
 
@@ -64,8 +69,11 @@ errorsable = stampit({
   splice: Array.prototype.splice
 }, {
   model: null,
-  messages: {},
+  messages: null,
   length: 0
+}, function() {
+  this.messages = {};
+  return this;
 });
 
 initializers = {
@@ -100,6 +108,7 @@ initializers = {
   create_validators: function(definitions) {
     var definition, name, validator, validator_options, _ref, _results;
 
+    this.validators = [];
     _ref = manager.validators;
     _results = [];
     for (name in _ref) {
@@ -136,7 +145,7 @@ initializers = {
 
 extensions = {
   model: {
-    validators: []
+    validators: null
   },
   record: {
     validate_attribute: function(attribute, doned, failed) {
@@ -144,7 +153,7 @@ extensions = {
 
       this.errors.messages[attribute] = null;
       results = [this, attribute];
-      _ref = model[this.resource].validators;
+      _ref = model[this.resource.toString()].validators;
       for (_i = 0, _len = _ref.length; _i < _len; _i++) {
         validator = _ref[_i];
         if (validator.attribute_name === attribute) {
@@ -164,7 +173,7 @@ extensions = {
       }
       this.errors.clear();
       results = [this];
-      _ref = model[this.resource].validators;
+      _ref = model[this.resource.toString()].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]));
@@ -213,4 +222,6 @@ require('./validations/presence');
 
 require('./validations/remote');
 
+require('./validations/type');
+
 require('./validations/cpf');

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

@@ -7,7 +7,7 @@ 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);
+      return record.errors.add("" + attribute + "_confirmation", 'confirmation', this.options);
     }
   }
 });