ende 0.5.1 → 0.5.2

data/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.1",
+  "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 → observable/es6-modules}/lib/adapters/rivets.js

@@ -3,7 +3,9 @@ exports.adapter = {
     if (record == null) {
       throw new TypeError('observable.adapters.rivets.subscribe: No record provided for subscription');
     }
-    return record.subscribe(attribute_path, callback);
+    if (attribute_path) {
+      return record.subscribe(attribute_path, callback);
+    }
   },
   unsubscribe: function(record, attribute_path, callback) {
     if (record == null) {

data/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/observable/es6-modules/lib/legacy/schedulerable.js

@@ -0,0 +1,114 @@
+import lookup from '../lookup.js';
+import jQuery from 'jquery';
+var scheduler, schedulerable;
+
+scheduler = function(options) {
+  var name, timeout, value;
+
+  if (options == null) {
+    options = {};
+  }
+  timeout = null;
+  for (name in options) {
+    value = options[name];
+    options[name] = {
+      value: value
+    };
+  }
+  jQuery.extend(options, {
+    keypaths: {
+      value: []
+    },
+    schedule: {
+      value: function() {
+        var deliver,
+          _this = this;
+
+        deliver = function() {
+          return _this.deliver();
+        };
+        clearTimeout(timeout);
+        return timeout = setTimeout(deliver, 20 || options.wait);
+      }
+    }
+  });
+  return Object.create(scheduler.methods, options);
+};
+
+jQuery.extend(scheduler, {
+  methods: {
+    property: function(object, keypath) {
+      var observer, observers, value;
+
+      if (this.keypaths.indexOf(keypath) !== -1) {
+        return;
+      }
+      this.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)) {
+        return observer.setValue(value);
+      }
+    },
+    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;
+          return this.observation.scheduler.schedule();
+        };
+      } else {
+        return function(value) {
+          this.observed[keypath] = value;
+          return this.observation.scheduler.schedule();
+        };
+      }
+    },
+    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) {
+  var original;
+
+  original = observable.methods.subscribe;
+  observable.methods.subscribe = function(keypath, callback) {
+    original.apply(this, arguments);
+    if (typeof keypath !== 'function') {
+      return this.observation.scheduler.property(this, keypath);
+    }
+  };
+  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/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/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/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() {
+    var keypath, observer, _ref, _results;
+
+    _ref = this.observers;
+    _results = [];
+    for (keypath in _ref) {
+      observer = _ref[keypath];
+      _results.push(observer.deliver());
+    }
+    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/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;

data/components/indefinido/observable/es6-modules/lib/observable/self_observer.js

@@ -0,0 +1,38 @@
+import {ObjectObserver} from '../../vendor/observe-js/observe.js';
+import {Callbacks} from 'jquery';
+var SelfObserver,
+  __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; };
+
+SelfObserver = (function(_super) {
+  __extends(SelfObserver, _super);
+
+  function SelfObserver(object) {
+    _super.call(this, object);
+    this.callbacks = Callbacks();
+    this.open((function() {
+      return this.fireWith(object, arguments);
+    }), this.callbacks);
+  }
+
+  SelfObserver.prototype.add = function(callback) {
+    return this.callbacks.add(callback);
+  };
+
+  SelfObserver.prototype.remove = function() {
+    var _ref;
+
+    return (_ref = this.callbacks).remove.apply(_ref, arguments);
+  };
+
+  SelfObserver.prototype.close = function() {
+    SelfObserver.__super__.close.apply(this, arguments);
+    this.callbacks.empty();
+    return delete this.callbacks;
+  };
+
+  return SelfObserver;
+
+})(ObjectObserver);
+
+export default SelfObserver;

data/components/indefinido/observable/es6-modules/lib/observable.js

@@ -0,0 +1,90 @@
+import './platform.js';
+import jQuery          from 'jquery';
+import observation     from './observable/observation.js';
+import selection       from './observable/selection.js';
+import KeypathObserver from './observable/keypath_observer.js';
+import SelfObserver    from './observable/self_observer.js';
+var observable;
+
+observable = function() {
+  var object;
+
+  object = observable.select.apply(this, arguments);
+  if (object.observation) {
+    return object;
+  }
+  return jQuery.extend(observable.observe(object), observable.methods);
+};
+
+jQuery.extend(observable, {
+  select: selection(observable),
+  observe: function(object) {
+    Object.defineProperty(object, "observation", {
+      configurable: true,
+      enumerable: false,
+      value: observation(object)
+    });
+    return Object.defineProperty(object, "observed", {
+      configurable: true,
+      enumerable: false,
+      value: {}
+    });
+  },
+  self: function(object) {
+    var observer, observers;
+
+    observers = object.observation.observers;
+    return observer = observers.self || (observers.self = new SelfObserver(object));
+  },
+  keypath: function(object, keypath) {
+    var observer, observers;
+
+    observers = object.observation.observers;
+    return observer = observers[keypath] || (observers[keypath] = new KeypathObserver(object, keypath));
+  },
+  unobserve: function(object) {
+    var name;
+
+    if (!object.observation) {
+      return object;
+    }
+    for (name in observable.methods) {
+      delete object[name];
+    }
+    object.observation.destroy();
+    object.observation.scheduler.destroy();
+    delete object.observation;
+    delete object.observed;
+    return object;
+  },
+  methods: {
+    subscribe: function(keypath_or_callback, callback) {
+      var observer;
+
+      switch (arguments.length) {
+        case 1:
+          observer = observable.self(this);
+          return this.observation.add('self', keypath_or_callback);
+        case 2:
+          observable.keypath(this, keypath_or_callback);
+          return this.observation.add(keypath_or_callback, callback);
+      }
+    },
+    unsubscribe: function(keypath, callback) {
+      return this.observation[callback ? 'remove' : 'mute'](keypath, callback);
+    },
+    publish: function(keypath, value) {
+      return this[keypath] = value;
+    }
+  },
+  ignores: []
+});
+
+if (!Object.observe) {
+  import schedulerable from './legacy/schedulerable.js';
+  observable = schedulerable(observable);
+}
+
+observable.mixin = observable;
+
+export default observable;

data/components/indefinido/observable/es6-modules/lib/platform.js

@@ -0,0 +1,12 @@
+if (!Object.prototype.create) {
+  require("../vendor/shims/object.create");
+}
+
+if (!Array.prototype.indexOf) {
+  require("../vendor/shims/array.indexOf");
+}
+
+if (typeof require !== "undefined") {
+  require("../vendor/shims/accessors-legacy.js");
+  require("../vendor/shims/accessors.js");
+}