ende 0.5.20 → 0.5.21

data/components/indefinido/indemma/master/components/indefinido/observable/es6-modules/vendor/shims/accessors-legacy.js

@@ -0,0 +1,92 @@
+/*
+ * Xccessors Legacy: Cross-browser legacy non-standard accessors
+ * http://github.com/eligrey/Xccessors
+ *
+ * 2010-03-21
+ *
+ * By Elijah Grey, http://eligrey.com
+ *
+ * A shim that implements __defineGetter__, __defineSetter__, __lookupGetter__,
+ * and __lookupSetter__
+ * in browsers that have ECMAScript 5 accessor support but not the legacy methods.
+ *
+ * Public Domain.
+ * NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.
+*/
+
+/*global Element, Window, HTMLDocument */
+
+/*jslint white: true, undef: true, nomen: true, eqeqeq: true, bitwise: true, regexp: true,
+  strict: true, newcap: true, immed: true, maxlen: 90 */
+
+/*! @source http://purl.eligrey.com/github/Xccessors/blob/master/xccessors-legacy.js*/
+
+"use strict";
+
+(function () {
+    var
+    defineProp = Object.defineProperty,
+    getProp    = Object.getOwnPropertyDescriptor,
+
+    // methods being implemented
+    methods    = [
+        "__defineGetter__", "__defineSetter__", "__lookupGetter__", "__lookupSetter__"
+    ],
+
+    // objects to implement legacy methods onto their prototypes
+    // Object.prototype[method] doesn't work on everything for IE
+    extend     = [Object, String, Array, Function, Boolean, Number,
+                 RegExp, Date, Error],
+    len        = extend.length,
+    proto      = "prototype",
+    extendMethod = function (method, fun) {
+        var i = len;
+        if (!(method in {})) {
+            while (i--) {
+              defineProp(extend[i][proto], method, {value: fun, enumerable: false})
+            }
+        }
+    };
+
+    // IE8 Does not support enumerable key so we abort!
+    // TODO Fix this without cluttering the prototype
+    try {defineProp({}, 'domo', {value: true, enumerable: false})} catch (e) {return;}
+
+    // IE7 Does not have Element, Window defined, so we check here
+    if (typeof Element != 'undefined') extend.push(Element);
+    if (typeof Window != 'undefined') extend.push(Window);
+
+    // IE9 Does not have html document defined, so we check here
+    if (typeof HTMLDocument != 'undefined') extend.push(HTMLDocument);
+
+
+    if (defineProp) {
+        extendMethod(methods[0], function (prop, fun) { // __defineGetter__
+            defineProp(this, prop, { get: fun });
+        });
+
+        extendMethod(methods[1], function (prop, fun) { // __defineSetter__
+            defineProp(this, prop, { set: fun });
+        });
+    }
+
+    if (getProp && !defineProp.requiresDomElement) {
+      extendMethod(methods[2], function (prop) { // __lookupGetter__
+        var descriptor = getProp(this, prop);
+        if (descriptor && descriptor.get) return descriptor.get;
+
+         // look in prototype too
+        descriptor = getProp(this.constructor[proto], prop);
+        if (descriptor && descriptor.get) return descriptor.get;
+      });
+
+      extendMethod(methods[3], function (prop) { // __lookupSetter__
+        var descriptor = getProp(this, prop);
+        if (descriptor && descriptor.set) return descriptor.set;
+
+        // look in prototype too
+        descriptor = getProp(this.constructor[proto], prop);
+        if (descriptor && descriptor.set) return descriptor.set;
+      });
+    }
+}());

data/components/indefinido/indemma/master/components/indefinido/observable/es6-modules/vendor/shims/accessors.js

@@ -0,0 +1,248 @@
+'use strict';
+
+(function () {
+  // Cache native objects for better performacy and easy to use
+  // references
+  var ObjectProto = Object.prototype,
+  hasOwnProp = ObjectProto.hasOwnProperty,
+  getProp    = Object.getOwnPropertyDescriptor,
+  defineProp = Object.defineProperty,
+  objectCreate = Object.create,
+  toStrings = [],
+  features = null,
+  stack = [], detach,
+  fixedOwnProperty,
+   prototypeBase = [Object, String, Array, Function, Boolean, Number, RegExp, Date, Error];
+
+  // IE7 Does not have Element and Window defined, so only add them if
+  // they exists check here
+  if (typeof Element != 'undefined') prototypeBase.push(Element);
+  if (typeof Window  != 'undefined') prototypeBase.push(Window);
+
+  features = {
+    allowsNonEnumerableProperty: function () {
+      var broken = false;
+      try {
+        defineProp({}, 'x', {})
+      } catch(e) {
+        broken = true;
+      }
+
+      return (!broken) && (!!defineProp);
+    },
+    supportsOnPropertyChangeEvent: function () {
+      var test = document.createElement('domo');
+      return 'onpropertychange' in test
+    }
+  }
+
+  if (!features.allowsNonEnumerableProperty() && features.supportsOnPropertyChangeEvent()) {
+
+    // Check if node is on document
+    var inDocument = function inDocument (node) {
+      var curr = node;
+      while (curr != null) {
+        curr = curr.parentNode;
+        if (curr == document) return true;
+      }
+      return false;
+    },
+
+    // Generate property event handler for setting some property
+    generate_setter = function generate_setter (object, property, descriptor) {
+      var setter = function object_define_property_shim_change_listener (event) {
+        var current_value, changed_value;
+        if (
+          // if we are setting this property
+          event.propertyName == property
+
+          // prevent firing setters again
+          // by checking callstack
+          && stack.indexOf(property) === -1
+        ) {
+          // Remove the event so it doesn't fire again and
+          // create a loop
+          object.detachEvent("onpropertychange", setter);
+
+          // If detaching the current setter
+          // just remove the event listener
+          if (detach) return;
+
+          // get the changed value, run it through the set function
+          changed_value = object[property];
+          descriptor.set.call(object, changed_value);
+
+          // Restore get function if:
+          //  it was mentioned on definition
+          //  there's no falsey value, in that case we just need to return falsey value
+          //  current toString is not the getter, to prevent further unecessary redefinitions
+          if (descriptor.get && descriptor.value && descriptor.value.toString != descriptor.bound_getter) {
+            // TODO if (descriptor.get + '' === 'undefined') descriptor.get = '';        // Handle undefined getter
+            descriptor.value.toString = descriptor.bound_getter
+          }
+
+          // Update stored values
+          object[property] = descriptor.value = changed_value;
+
+          // restore the event handler
+          object.attachEvent("onpropertychange", setter);
+
+          // stack.pop();
+          return false;
+        }
+      }
+
+      return setter;
+    };
+
+    // Shim define property with apropriated fail cases exceptions
+    Object.defineProperty = function (obj, prop, descriptor) {
+      var fix;
+
+      if (!prop)
+
+      if (descriptor.set) {
+        if (!obj.attachEvent) throw new TypeError('Object.defineProperty: First parameter must be a dom element. When descriptor has \'set\' property.');
+
+        if (!fix && !inDocument(obj)) throw new TypeError('Object.defineProperty: Dom element must be attached in document.');
+      }
+
+      if (!descriptor) throw new TypeError('Object.defineProperty (object, property, descriptor): Descriptor must be an object, was \'' + descriptor + '\'.');
+
+      // Store current value in descriptor
+      // TODO only try to set descriptor value if it was passed as parameter
+      descriptor.value = descriptor.value || (descriptor.get && descriptor.get.call(obj)) || obj[prop];
+
+      if (descriptor.set) {
+        // Detach old listeners if any
+        detach = true;
+        obj[prop] = 'detaching';
+        detach = false;
+
+        if (descriptor.get) {
+          // TODO remove jquery dependency
+          descriptor.bound_getter   = $.extend($.proxy(descriptor.get, obj), descriptor.get);
+
+          // Why? we only bind the getter when we have a non falsey value
+          if (descriptor.value) descriptor.value.toString = descriptor.bound_getter;
+
+          // Although its not allowed for convention to have getters
+          // and setters with the descriptor value, here we just reuse
+          // the descriptor stored value
+          obj[prop] = descriptor.value;
+        }
+
+        (fix || obj).attachEvent("onpropertychange", generate_setter(obj, prop, descriptor));
+
+      } else if (descriptor.get) {
+        descriptor.bound_getter   = $.extend($.proxy(descriptor.get, obj), descriptor.get);
+
+        // Why? we only bind the getter when we have a non falsey value
+        if (descriptor.value) descriptor.value.toString = descriptor.bound_getter;
+
+        // Although its not allowed for convention to have getters
+        // and setters with the descriptor value, here we just reuse
+        // the descriptor stored value
+        obj[prop] = descriptor.value;
+      } else {
+        obj[prop] = descriptor.value;
+      }
+
+      return obj;
+    }
+
+    // Allow others to check requirements for define property
+    Object.defineProperty.requiresDomElement = true
+  }
+
+
+  // Since we shimed define property, we can also shim defineProperties
+  if (!Object.defineProperties) {
+    Object.defineProperties = function (obj, props) {
+      for (var prop in props) {
+        if (hasOwnProp.call(props, prop)) {
+          Object.defineProperty(obj, prop, props[prop]);
+        }
+      }
+    };
+
+    baseElement      = document.createElement('fix');
+    fixedOwnProperty = function (name) {
+      if (name in baseElement) return false;
+      return hasOwnProp.call(this, name);
+    };
+
+
+    Object.create = function (prototype, properties) {
+      var complexDescriptor, fix, descriptor, name;
+
+      for (name in properties) {
+        descriptor = properties[name]
+        if (descriptor instanceof Object) {
+          complexDescriptor = !!(descriptor.get || descriptor.set)
+
+          if (complexDescriptor) {
+            break;
+          }
+        }
+      }
+
+      if (complexDescriptor || prototype.nodeName === 'fix' || properties && properties._shim) {
+        properties && delete properties._shim;
+
+        if (typeof object != 'function') {
+          fix = document.createElement('fix');
+          document.appendChild(fix);
+
+          // Copy over prototype properties
+          for (name in prototype) {
+            try {
+              if (name in baseElement) continue;
+              fix[name] = prototype[name];
+            } catch (e) {
+              console.warn("Object.create: Invalid shimmed property: " + name + ", with error " + e);
+            }
+          }
+
+          // Ensure most normalized for loops to work property, by
+          // skiping the dom element properties on own property
+          // checking.
+          //
+          // TODO ensure other own property methods checking
+          fix.hasOwnProperty = fixedOwnProperty
+
+          Object.defineProperties(fix, properties);
+        } else {
+          throw new TypeError('Functions with complex descriptors not implemented yet');
+        }
+        return fix;
+      } else {
+        return objectCreate(prototype, properties)
+      }
+    }
+  };
+
+
+  /* TODO Use define Property, and only define if
+     non-enumerable properties are allowed
+
+     also define __defineGetter__ and __defineSetter__
+  if (!Object.defineProperty.requiresDomElement) {
+    if (!Object.prototype.__lookupGetter__) {
+      Object.__lookupGetter__ = function () {
+      console && console.log('__lookupGetter__ not implemented yet');
+        return null;
+    }
+  }
+
+  if (!Object.__lookupSetter__) {
+    Object.prototype.__lookupSetter__ = function () {
+      console && console.log('__lookupSetter__ not implemented yet');
+      return null;
+      }
+      }
+    }
+  */
+
+})();
+

data/components/indefinido/indemma/master/components/indefinido/observable/es6-modules/vendor/shims/array.indexOf.js

@@ -0,0 +1,8 @@
+if (!Array.prototype.indexOf) { 
+    Array.prototype.indexOf = function(obj, start) {
+         for (var i = (start || 0), j = this.length; i < j; i++) {
+             if (this[i] === obj) { return i; }
+         }
+         return -1;
+    }
+}

data/components/indefinido/indemma/master/components/indefinido/observable/es6-modules/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/components/indefinido/indemma/master/components/pluma/assimilate/0.4.0/component.json

@@ -0,0 +1,25 @@
+{
+  "name": "assimilate",
+  "version": "0.4.0",
+  "license": "UNLICENSE",
+  "description": "Extends objects.",
+  "keywords": [
+    "extend",
+    "inherit",
+    "mixin"
+  ],
+  "main": "dist/assimilate.js",
+  "dependencies": {},
+  "development": {},
+  "scripts": [
+    "dist/assimilate.js"
+  ],
+  "styles": [],
+  "ignore": [
+    "**/.*",
+    "build",
+    "components",
+    "node_modules"
+  ],
+  "repository": "pluma/assimilate"
+}

data/components/indefinido/indemma/master/components/pluma/assimilate/0.4.0/dist/assimilate.js

@@ -0,0 +1,127 @@
+/*! assimilate 0.4.0 Original author Alan Plum <me@pluma.io>. Released into the Public Domain under the UNLICENSE. @preserve */
+var slice = Array.prototype.slice;
+
+function bind(fn, self) {
+    var args = slice.call(arguments, 2);
+    if (typeof Function.prototype.bind === 'function') {
+        return Function.prototype.bind.apply(fn, [self].concat(args));
+    }
+    return function() {
+        return fn.apply(self, args.concat(slice.call(arguments, 0)));
+    };
+}
+
+function simpleCopy(target, name, source) {
+    target[name] = source[name];
+}
+
+function properCopy(target, name, source) {
+    var descriptor = Object.getOwnPropertyDescriptor(source, name);
+    Object.defineProperty(target, name, descriptor);
+}
+
+function ownProperties(obj) {
+    return Object.getOwnPropertyNames(obj);
+}
+
+function allKeys(obj) {
+    var keys = [];
+    for (var name in obj) {
+        keys.push(name);
+    }
+    return keys;
+}
+
+function ownKeys(obj) {
+    var keys = [];
+    for (var name in obj) {
+        if (obj.hasOwnProperty(name)) {
+            keys.push(name);
+        }
+    }
+    return keys;
+}
+
+function assimilateWithStrategy(target) {
+    var strategy = this,
+    sources = slice.call(arguments, 1),
+    i, source, names, j, name;
+
+    if (target === undefined || target === null) {
+        target = {};
+    }
+
+    for (i = 0; i < sources.length; i++) {
+        source = sources[i];
+        names = strategy.keysFn(source);
+        for (j = 0; j < names.length; j++) {
+            name = names[j];
+            strategy.copyFn(target, name, source);
+        }
+    }
+
+    return target;
+}
+
+var strategies = {
+    DEFAULT: {
+        keysFn: ownKeys,
+        copyFn: simpleCopy
+    },
+    PROPER: {
+        keysFn: ownProperties,
+        copyFn: properCopy
+    },
+    INHERITED: {
+        keysFn: allKeys,
+        copyFn: simpleCopy
+    },
+    DEEP: {
+        keysFn: ownKeys,
+        copyFn: function recursiveCopy(target, name, source) {
+            var val = source[name];
+            var old = target[name];
+            if (typeof val === 'object' && typeof old === 'object') {
+                assimilateWithStrategy.call(strategies.DEEP, old, val);
+            } else {
+                simpleCopy(target, name, source);
+            }
+        }
+    },
+    STRICT: {
+        keysFn: ownKeys,
+        copyFn: function strictCopy(target, name, source) {
+            if (source[name] !== undefined) {
+                simpleCopy(target, name, source);
+            }
+        }
+    },
+    FALLBACK: {
+        keysFn: function fallbackCopy(target, name, source) {
+            if (target[name] === undefined) {
+                simpleCopy(target, name, source);
+            }
+        },
+        copyFn: simpleCopy
+    }
+};
+
+var assimilate = bind(assimilateWithStrategy, strategies.DEFAULT);
+assimilate.strategies = strategies;
+assimilate.withStrategy = function withStrategy(strategy) {
+    if (typeof strategy === 'string') {
+        strategy = strategies[strategy.toUpperCase()];
+    }
+    if (!strategy) {
+        throw new Error('Unknwon or invalid strategy:' + strategy);
+    }
+    if (typeof strategy.copyFn !== 'function') {
+        throw new Error('Strategy missing copy function:' + strategy);
+    }
+    if (typeof strategy.keysFn !== 'function') {
+        throw new Error('Strategy missing keys function:' + strategy);
+    }
+    return bind(assimilateWithStrategy, strategy);
+};
+
+module.exports = assimilate;

data/components/indefinido/indemma/master/karma.conf.js

@@ -0,0 +1,75 @@
+// Karma configuration
+
+module.exports = function(config) {
+  config.set({
+
+    // base path, that will be used to resolve files and exclude
+    basePath: '',
+
+
+    // frameworks to use
+    frameworks: ['mocha'],
+
+
+    // list of files / patterns to load in the browser
+    files: [
+        'build/test.js',
+        'spec/support/**/*.js',
+        'spec/spec_helper.js',
+        'spec/**/*.js'
+    ],
+
+    // list of files to excudle
+    exclude: [
+      'spec/coverage/**/*.js'
+    ],
+
+    client: {
+        mocha: {
+            ui: 'bdd'
+        }
+    },
+
+
+    // test results reporter to use
+    // possible values: 'dots', 'progress', 'junit', 'growl', 'coverage'
+    reporters: ['progress'],
+
+
+    // web server port
+    port: 9876,
+
+
+    // enable / disable colors in the output (reporters and logs)
+    colors: true,
+
+
+    // level of logging
+    // possible values: config.LOG_DISABLE || config.LOG_ERROR || config.LOG_WARN || config.LOG_INFO || config.LOG_DEBUG
+    logLevel: config.LOG_INFO,
+
+
+    // enable / disable watching file and executing tests whenever any file changes
+    autoWatch: true,
+
+
+    // Start these browsers, currently available:
+    // - Chrome
+    // - ChromeCanary
+    // - Firefox
+    // - Opera (has to be installed with `npm install karma-opera-launcher`)
+    // - Safari (only Mac; has to be installed with `npm install karma-safari-launcher`)
+    // - PhantomJS
+    // - IE (only Windows; has to be installed with `npm install karma-ie-launcher`)
+    browsers: ['Chrome'],
+
+
+    // If browser does not capture in given timeout [ms], kill it
+    captureTimeout: 60000,
+
+
+    // Continuous Integration mode
+    // if true, it capture browsers, run tests and exit
+    singleRun: false
+  });
+};

data/components/indefinido/indemma/master/lib/record/associable.js

@@ -99,8 +99,10 @@ descriptors = {
 
         association_name = this.resource.toString();
         if (resource_id == null) {
-          this.dirty = true;
-          this.owner[association_name] = null;
+          if (this.owner[association_name] || this.owner[association_name + '_id']) {
+            this.dirty = true;
+            this.owner[association_name] = null;
+          }
           return resource_id;
         }
         current_resource_id = (_ref = this.owner.observed[association_name]) != null ? _ref._id : void 0;

data/components/indefinido/indemma/master/lib/record/dirtyable.js

@@ -2,7 +2,7 @@
 var dirtyable, model, record;
 
 dirtyable = {
-  ignores: ['dirty', 'resource', 'route', 'initial_route', 'after_initialize', 'before_initialize', 'parent_resource', 'nested_attributes', 'reloading', 'ready', 'saving', 'salvation', 'sustained', 'element', 'default', 'lock', 'validated', 'validation', 'errors', 'dirty'],
+  ignores: ['dirty', 'resource', 'route', 'initial_route', 'after_initialize', 'before_initialize', 'parent_resource', 'nested_attributes', 'reloading', 'ready', 'saving', 'saved', 'failed', 'salvation', 'sustained', 'element', 'default', 'lock', 'validate', 'validated', 'validation', 'errors', 'dirty', 'json'],
   reserved_filter: function(name) {
     return this.ignores.indexOf(name) === -1;
   },

data/components/indefinido/indemma/master/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "indemma",
+  "version": "0.2.12",
+  "devDependencies": {
+    "mocha": "*",
+    "karma": "~0.10",
+    "karma-mocha": "~0.1"
+  }
+}