ende 0.5.20 → 0.5.21

data/components/indefinido/indemma/master/components/component/type/1.0.0/component.json

@@ -0,0 +1,20 @@
+{
+  "name": "type",
+  "description": "Cross-browser type assertions (less broken typeof)",
+  "version": "1.0.0",
+  "keywords": [
+    "typeof",
+    "type",
+    "utility"
+  ],
+  "dependencies": {},
+  "development": {
+    "dependencies": {
+      "component/assert": "*"
+    }
+  },
+  "scripts": [
+    "index.js"
+  ],
+  "repository": "component/type"
+}

data/components/indefinido/indemma/master/components/component/type/1.0.0/index.js

@@ -0,0 +1,32 @@
+
+/**
+ * toString ref.
+ */
+
+var toString = Object.prototype.toString;
+
+/**
+ * Return the type of `val`.
+ *
+ * @param {Mixed} val
+ * @return {String}
+ * @api public
+ */
+
+module.exports = function(val){
+  switch (toString.call(val)) {
+    case '[object Function]': return 'function';
+    case '[object Date]': return 'date';
+    case '[object RegExp]': return 'regexp';
+    case '[object Arguments]': return 'arguments';
+    case '[object Array]': return 'array';
+    case '[object String]': return 'string';
+  }
+
+  if (val === null) return 'null';
+  if (val === undefined) return 'undefined';
+  if (val && val.nodeType === 1) return 'element';
+  if (val === Object(val)) return 'object';
+
+  return typeof val;
+};

data/components/indefinido/indemma/master/components/indefinido/advisable/master/component.json

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

data/components/indefinido/indemma/master/components/indefinido/advisable/master/index.js

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

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

@@ -0,0 +1,39 @@
+{
+  "name": "observable",
+  "repository": "indefinido/observable",
+  "description": "Observable capabilities built upon observable shim.",
+  "version": "0.2.4",
+  "keywords": [],
+  "dependencies": {
+    "component/jquery": "*"
+  },
+  "main": "index.js",
+  "development": {
+    "dependencies": {
+      "chaijs/chai": "*"
+    },
+    "scripts": [
+      "vendor/spec/sinon.js",
+      "vendor/spec/sinon/**/*.js"
+    ]
+  },
+  "license": "WTFPL",
+  "scripts": [
+    "index.js",
+    "lib/adapters/rivets.js",
+    "lib/legacy/notifierable.js",
+    "lib/legacy/schedulerable.js",
+    "lib/lookup.js",
+    "lib/observable.js",
+    "lib/observable/keypath_observer.js",
+    "lib/observable/observation.js",
+    "lib/observable/selection.js",
+    "lib/observable/self_observer.js",
+    "lib/platform.js",
+    "vendor/observe-js/observe.js",
+    "vendor/shims/accessors-legacy.js",
+    "vendor/shims/accessors.js",
+    "vendor/shims/array.indexOf.js",
+    "vendor/shims/object.create.js"
+  ]
+}

data/components/indefinido/indemma/master/components/indefinido/observable/es6-modules/index.js

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

data/components/indefinido/indemma/master/components/indefinido/observable/es6-modules/lib/adapters/rivets.js

@@ -0,0 +1,40 @@
+var adapter;
+
+adapter = {
+  subscribe: function(record, attribute_path, callback) {
+    if (record == null) {
+      throw new TypeError('observable.adapters.rivets.subscribe: No record provided for subscription');
+    }
+    if (attribute_path) {
+      return record.subscribe(attribute_path, callback);
+    }
+  },
+  unsubscribe: function(record, attribute_path, callback) {
+    if (record == null) {
+      throw new TypeError('observable.adapters.rivets.unsubscribe: No record provided for subscription');
+    }
+    return record.unsubscribe(attribute_path, callback);
+  },
+  read: function(record, attribute_path) {
+    if (record == null) {
+      throw new TypeError('observable.adapters.rivets.read: No record provided for subscription');
+    }
+    if (attribute_path.indexOf('.') === -1) {
+      return record[attribute_path];
+    } else {
+      return record.observation.observers[attribute_path].value_;
+    }
+  },
+  publish: function(record, attribute_path, value) {
+    if (record == null) {
+      throw new TypeError('observable.adapters.rivets.publish: No record provided for subscription');
+    }
+    if (attribute_path.indexOf('.') === -1) {
+      return record[attribute_path] = value;
+    } else {
+      return record.observation.observers[attribute_path].setValue(value);
+    }
+  }
+};
+
+export default adapter;

data/components/indefinido/indemma/master/components/indefinido/observable/es6-modules/lib/legacy/notifierable.js

@@ -0,0 +1,145 @@
+import jQuery from 'jquery';
+var mutations, notifierable, subscribed_getter;
+
+notifierable = {
+  observe: function(object, keypath, callback) {
+    return Object.defineProperty(object, keypath, {
+      get: this.getter(object, keypath),
+      set: this.setter(object, keypath, callback),
+      enumerable: true
+    });
+  },
+  storage_for: function(object) {
+    var toJSON;
+
+    toJSON = void 0;
+    Object.defineProperty(object, "observed", {
+      configurable: true,
+      enumerable: false,
+      value: {}
+    });
+    toJSON = object.json || object.toJSON;
+    if (toJSON) {
+      return Object.defineProperty(object, "toJSON", {
+        enumerable: false,
+        value: function() {
+          var json;
+
+          json = void 0;
+          json = toJSON.apply(this, arguments);
+          return observable.unobserve(_.omit(json, observable.ignores, ["toJSON", "observed"]));
+        }
+      });
+    }
+  },
+  setter: function(object, keypath, callback) {
+    var current, old_setter, setter, thread;
+
+    setter = lookup.setter.call(object, keypath);
+    this.observed[keypath] = lookup.getter.call(object, keypath) && lookup.getter.call(object, keypath)() || object[keypath];
+    if (!setter) {
+      setter = function(value) {
+        return check.call(object, keypath, value) !== false && setter.callback_thread.call(object, value);
+      };
+    } else if (!setter.callback_thread) {
+      old_setter = setter;
+      setter = function(value) {
+        return check.call(object, keypath, value) !== false && setter.callback_thread.call(object, value);
+      };
+      setter.callback_thread = old_setter;
+    }
+    current = setter.callback_thread || $.noop;
+    setter.callback_thread = thread = function(value) {
+      return current.call(object, value) !== false && callback.call(object, value);
+    };
+    if (requiresDomElement) {
+      this.observed[keypath + "_setter"] = setter;
+    }
+    return setter;
+  },
+  getter: subscribed_getter = function(object, keypath) {
+    var getter, root_getter;
+
+    getter = lookup.getter.call(object, keypath) || (root_getter = function() {
+      return object.observed[keypath];
+    });
+    if (requiresDomElement) {
+      this.observed[keypath + "_getter"] = getter;
+    }
+    return getter;
+  },
+  mutations: function(keypath) {
+    var array, setter;
+
+    setter = lookup.setter.call(this, keypath);
+    array = this[keypath];
+    if (!setter) {
+      this.observe.call(this, keypath, function(new_array) {
+        var i, j, type;
+
+        i = void 0;
+        type = void 0;
+        j = void 0;
+        if ($.type(new_array) !== "array") {
+          return;
+        }
+        if (new_array.object === array.object && new_array.thread === array.thread) {
+          return;
+        }
+        i = new_array.length;
+        j = new_array.length;
+        new_array.thread = array.thread;
+        new_array.object = array.object;
+        new_array.key = keypath;
+        while (i--) {
+          type = $.type(new_array[i]);
+          if (!new_array[i].observed && (type === "object" || type === "array")) {
+            new_array[i] = observable(new_array[i]);
+          }
+        }
+        new_array.length = j;
+        $.extend(new_array, mutations.overrides);
+      });
+      setter = lookup.setter.call(this, keypath);
+    }
+    array.thread = setter.callback_thread;
+    array.object = this;
+    array.key = keypath;
+    $.extend(array, mutations.overrides);
+    if (!this.observed.mutate) {
+      this.observed.mutate = mutations.mutate;
+    }
+  }
+};
+
+mutations = {
+  mutate: function(thread, method, array) {
+    array.method = method;
+    thread.call(this, array);
+    this.publish(array.key, array);
+    delete array.method;
+  },
+  overrides: {
+    push: function() {
+      var i, operation;
+
+      i = arguments.length;
+      operation = void 0;
+      while (i--) {
+        !arguments[i].observed && $.type(arguments[i]) === "object" && (arguments[i] = observable(arguments[i]));
+      }
+      operation = Array.prototype.push.apply(this, arguments);
+      this.object.observed.mutate.call(this.object, this.thread, "push", this);
+      return operation;
+    }
+  }
+};
+
+jQuery("pop shift unshift".split(" ")).each(function(i, method) {
+  return mutations.overrides[method] = function() {
+    Array.prototype[method].apply(this, arguments);
+    return this.object.observed.mutate.call(this.object, this.thread, method, this);
+  };
+});
+
+export default notifierable;

data/components/indefinido/indemma/master/components/indefinido/observable/es6-modules/lib/legacy/schedulerable.js

@@ -0,0 +1,147 @@
+import lookup      from '../lookup.js';
+import jQuery      from 'jquery';
+var scheduler, schedulerable;
+
+scheduler = function(options) {
+  var name, value;
+
+  if (options == null) {
+    options = {};
+  }
+  for (name in options) {
+    value = options[name];
+    options[name] = {
+      value: value
+    };
+  }
+  jQuery.extend(options, {
+    schedulable_keypaths: {
+      value: []
+    },
+    schedule: {
+      value: function() {
+        var deliver,
+          _this = this;
+
+        deliver = function() {
+          return _this.deliver();
+        };
+        clearTimeout(this.timer);
+        return this.timer = setTimeout(deliver, 20 || options.wait);
+      }
+    }
+  });
+  return Object.create(scheduler.methods, options);
+};
+
+jQuery.extend(scheduler, {
+  methods: {
+    schedulable: function(object, keypath) {
+      var observer, observers, value;
+
+      if (this.schedulable_keypaths.indexOf(keypath) !== -1) {
+        return;
+      }
+      this.schedulable_keypaths.push(keypath);
+      observers = object.observation.observers;
+      observer = observers[keypath];
+      value = observer.path_.getValueFrom(object);
+      Object.defineProperty(object, keypath, {
+        get: this.getter(object, keypath),
+        set: this.setter(object, keypath),
+        enumerable: true,
+        configurable: true
+      });
+      if (value !== observer.path_.getValueFrom(object)) {
+        observer.setValue(value);
+        return object.observation.deliver();
+      }
+    },
+    deliver: function() {
+      return this.target.observation.deliver();
+    },
+    setter: function(object, keypath, callback) {
+      var current_setter;
+
+      current_setter = lookup.setter.call(object, keypath);
+      if (current_setter) {
+        return function(value) {
+          current_setter.call(this, value);
+          this.observed[keypath] = value;
+          this.observation.scheduler.schedule();
+          return value;
+        };
+      } else {
+        return function(value) {
+          this.observed[keypath] = value;
+          this.observation.scheduler.schedule();
+          return value;
+        };
+      }
+    },
+    getter: function(object, keypath) {
+      var root_getter;
+
+      return lookup.getter.call(object, keypath) || (root_getter = function() {
+        return this.observed[keypath];
+      });
+    },
+    destroy: function() {
+      return this.target = null;
+    }
+  }
+});
+
+schedulerable = function(observable) {
+  schedulerable.storage_for(observable);
+  schedulerable.schedulable_observers();
+  return schedulerable.augment(observable);
+};
+
+schedulerable.storage_for = function(observable) {};
+
+schedulerable.schedulable_observers = function() {
+  import {Path} from '../../vendor/observe-js/observe.js';
+  var original;
+
+  original = Path.prototype.setValueFrom;
+  return Path.prototype.setValueFrom = function(object) {
+    var changed;
+
+    changed = original.apply(this, arguments);
+    if (changed) {
+      return object.observation.scheduler.schedule();
+    }
+  };
+};
+
+schedulerable.augment = function(observable) {
+  var subscribe, unobserve;
+
+  subscribe = observable.methods.subscribe;
+  observable.methods.subscribe = function(keypath, callback) {
+    subscribe.apply(this, arguments);
+    if (typeof keypath !== 'function') {
+      return this.observation.scheduler.schedulable(this, keypath);
+    }
+  };
+  unobserve = observable.unobserve;
+  observable.unobserve = function(object) {
+    if (!object.observation) {
+      return object;
+    }
+    object.observation.scheduler.destroy();
+    return unobserve.apply(this, arguments);
+  };
+  return jQuery.extend((function() {
+    var object;
+
+    object = observable.apply(this, arguments);
+    object.observation.scheduler = scheduler({
+      target: object
+    });
+    return object;
+  }), observable);
+};
+
+export default schedulerable;

data/components/indefinido/indemma/master/components/indefinido/observable/es6-modules/lib/lookup.js

@@ -0,0 +1,38 @@
+var lookup;
+
+lookup = {
+  setter: Object.prototype.__lookupSetter__ || function(property) {
+    return this.observed && this.observed[property + "_setter"];
+  },
+  getter: Object.prototype.__lookupGetter__ || function(property) {
+    var default_getter;
+
+    default_getter = void 0;
+    return this.observed && this.observed[property + "_getter"] || ((default_getter = $.proxy(lookup.default_getter, this, property)) && (default_getter.is_default = true) && default_getter);
+  },
+  types: {
+    undefined: undefined,
+    "null": null,
+    "true": true,
+    "false": false,
+    NaN: NaN
+  },
+  basic_types: [undefined, null],
+  default_getter: function(property) {
+    var possible_value;
+
+    possible_value = this[property];
+    if (possible_value && possible_value.hasOwnProperty("toString")) {
+      if (possible_value.toString.is_default) {
+        return this.observed[property];
+      }
+      return possible_value.toString.call(this);
+    } else if (possible_value in lookup.types) {
+      return lookup.types[possible_value];
+    } else {
+      return possible_value;
+    }
+  }
+};
+
+export default lookup;

data/components/indefinido/indemma/master/components/indefinido/observable/es6-modules/lib/observable/keypath_observer.js

@@ -0,0 +1,38 @@
+import {PathObserver} from '../../vendor/observe-js/observe.js';
+import {Callbacks} from 'jquery';
+var KeypathObserver,
+  __hasProp = {}.hasOwnProperty,
+  __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+
+KeypathObserver = (function(_super) {
+  __extends(KeypathObserver, _super);
+
+  function KeypathObserver(object, keypath) {
+    _super.call(this, object, keypath);
+    this.callbacks = Callbacks();
+    this.open((function() {
+      return this.fireWith(object, arguments);
+    }), this.callbacks);
+  }
+
+  KeypathObserver.prototype.add = function(callback) {
+    return this.callbacks.add(callback);
+  };
+
+  KeypathObserver.prototype.remove = function() {
+    var _ref;
+
+    return (_ref = this.callbacks).remove.apply(_ref, arguments);
+  };
+
+  KeypathObserver.prototype.close = function() {
+    KeypathObserver.__super__.close.apply(this, arguments);
+    this.callbacks.empty();
+    return delete this.callbacks;
+  };
+
+  return KeypathObserver;
+
+})(PathObserver);
+
+export default KeypathObserver;

data/components/indefinido/indemma/master/components/indefinido/observable/es6-modules/lib/observable/observation.js

@@ -0,0 +1,45 @@
+var observation, observationable;
+
+observation = {
+  add: function(keypath, callback) {
+    return this.observers[keypath].add(callback);
+  },
+  remove: function(keypath, callback) {
+    return this.observers[keypath].remove(callback);
+  },
+  deliver: function(discard) {
+    var keypath, observer, _ref, _results;
+
+    _ref = this.observers;
+    _results = [];
+    for (keypath in _ref) {
+      observer = _ref[keypath];
+      _results.push(observer.deliver(discard));
+    }
+    return _results;
+  },
+  mute: function(keypath) {
+    this.observers[keypath].close();
+    return delete this.observers[keypath];
+  },
+  destroy: function(keypath) {
+    var observer, _ref;
+
+    _ref = this.observers;
+    for (keypath in _ref) {
+      observer = _ref[keypath];
+      observer.close();
+    }
+    return delete this.observers;
+  }
+};
+
+observationable = function(object) {
+  return Object.create(observation, {
+    observers: {
+      value: {}
+    }
+  });
+};
+
+export default observationable;

data/components/indefinido/indemma/master/components/indefinido/observable/es6-modules/lib/observable/selection.js

@@ -0,0 +1,57 @@
+import jQuery from 'jquery';
+var requiresDomElement, selection;
+
+requiresDomElement = Object.defineProperty.requiresDomElement;
+
+selection = function(observable) {
+  if (requiresDomElement) {
+    selection.generate_ignores(observable);
+    return selection.legacy;
+  } else {
+    return selection.from_call;
+  }
+};
+
+selection.legacy = function() {
+  var fix, object;
+
+  object = selection.from_call.apply(this, arguments);
+  if (!jQuery.isReady) {
+    throw new Error("observable.call: For compatibility reasons, observable can only be called when dom is loaded.");
+  }
+  if (typeof object.nodeName !== "string") {
+    fix = document.createElement("fix");
+    document.body.appendChild(fix);
+    object = jQuery.extend(fix, object);
+  }
+  return object;
+};
+
+selection.generate_ignores = function(observable) {
+  var fix_ignores, ignores, property;
+
+  ignores = document.createElement("fix");
+  fix_ignores = [];
+  property = void 0;
+  for (property in ignores) {
+    fix_ignores.push(property);
+  }
+  return observable.ignores = fix_ignores;
+};
+
+selection.from_call = function(param) {
+  var object;
+
+  if (this === window) {
+    object = param || {};
+  } else if (this !== window) {
+    if (param) {
+      throw new TypeError("Two objects provided! Call either with observable.call(object) or observable(object), not with observable.call(param, param)");
+    } else {
+      object = this;
+    }
+  }
+  return object;
+};
+
+export default selection;