luca 0.9.9 → 0.9.42

data/vendor/assets/luca-ui/framework.js

@@ -0,0 +1,110 @@
+(function() {
+
+  _.mixin(_.string);
+
+  window.Luca = {
+    VERSION: "0.6.1",
+    core: {},
+    containers: {},
+    components: {},
+    modules: {},
+    fields: {},
+    util: {},
+    registry: {
+      classes: {},
+      namespaces: ["Luca.containers", "Luca.components"]
+    },
+    component_cache: {
+      cid_index: {},
+      name_index: {}
+    }
+  };
+
+  Luca.enableBootstrap = true;
+
+  Luca.registry.addNamespace = function(identifier) {
+    Luca.registry.namespaces.push(identifier);
+    return Luca.registry.namespaces = _(Luca.registry.namespaces).uniq();
+  };
+
+  Luca.cache = function(needle, component) {
+    var lookup_id;
+    if (component != null) Luca.component_cache.cid_index[needle] = component;
+    component = Luca.component_cache.cid_index[needle];
+    if ((component != null ? component.component_name : void 0) != null) {
+      Luca.component_cache.name_index[component.component_name] = component.cid;
+    } else if ((component != null ? component.name : void 0) != null) {
+      Luca.component_cache.name_index[component.name] = component.cid;
+    }
+    if (component != null) return component;
+    lookup_id = Luca.component_cache.name_index[needle];
+    return Luca.component_cache.cid_index[lookup_id];
+  };
+
+  Luca.util.nestedValue = function(accessor, source_object) {
+    return _(accessor.split(/\./)).inject(function(obj, key) {
+      return obj = obj != null ? obj[key] : void 0;
+    }, source_object);
+  };
+
+  Luca.registry.lookup = function(ctype) {
+    var c, className, parents;
+    c = Luca.registry.classes[ctype];
+    if (c != null) return c;
+    className = _.camelize(_.capitalize(ctype));
+    parents = _(Luca.registry.namespaces).map(function(namespace) {
+      return Luca.util.nestedValue(namespace, window || global);
+    });
+    return _.first(_.compact(_(parents).map(function(parent) {
+      return parent[className];
+    })));
+  };
+
+  Luca.util.lazyComponent = function(config) {
+    var componentClass, constructor, ctype;
+    ctype = config.ctype;
+    componentClass = Luca.registry.lookup(ctype);
+    if (!componentClass) {
+      throw "Invalid Component Type: " + ctype + ".  Did you forget to register it?";
+    }
+    constructor = eval(componentClass);
+    return new constructor(config);
+  };
+
+  Luca.register = function(component, constructor_class) {
+    var exists;
+    exists = Luca.registry.classes[component];
+    if (exists != null) {
+      throw "Can not register component with the signature " + component + ". Already exists";
+    } else {
+      return Luca.registry.classes[component] = constructor_class;
+    }
+  };
+
+  Luca.available_templates = function(filter) {
+    var available;
+    if (filter == null) filter = "";
+    available = _(Luca.templates).keys();
+    if (filter.length > 0) {
+      return _(available).select(function(tmpl) {
+        return tmpl.match(filter);
+      });
+    } else {
+      return available;
+    }
+  };
+
+  Luca.util.isIE = function() {
+    try {
+      Object.defineProperty({}, '', {});
+      return false;
+    } catch (e) {
+      return true;
+    }
+  };
+
+  $((function() {
+    return $('body').addClass('luca-ui-enabled');
+  })());
+
+}).call(this);

data/vendor/assets/luca-ui/index.js

@@ -0,0 +1,5 @@
+(function() {
+
+
+
+}).call(this);

data/vendor/assets/luca-ui/managers/collection_manager.js

@@ -0,0 +1,98 @@
+(function() {
+  var instances;
+
+  instances = [];
+
+  Luca.CollectionManager = (function() {
+
+    CollectionManager.prototype.__collections = {};
+
+    function CollectionManager(options) {
+      this.options = options != null ? options : {};
+      _.extend(this, this.options);
+      _.extend(this, Backbone.Events);
+      instances.push(this);
+    }
+
+    CollectionManager.prototype.add = function(key, collection) {
+      return this.currentScope()[key] = collection;
+    };
+
+    CollectionManager.prototype.allCollections = function() {
+      return _(this.currentScope()).values();
+    };
+
+    CollectionManager.prototype.create = function(key, collectionOptions, initialModels, private) {
+      var CollectionClass, collection;
+      if (collectionOptions == null) collectionOptions = {};
+      if (initialModels == null) initialModels = [];
+      if (private == null) private = false;
+      CollectionClass = collectionOptions.base;
+      CollectionClass || (CollectionClass = this.guessCollectionClass(key));
+      if (private || collectionOptions.private) {
+        collectionOptions.registerWith = "";
+      }
+      collection = new CollectionClass(initialModels, collectionOptions);
+      this.add(key, collection);
+      return collection;
+    };
+
+    CollectionManager.prototype.collectionNamespace = Luca.Collection.namespace;
+
+    CollectionManager.prototype.currentScope = function() {
+      var current_scope, _base;
+      if (current_scope = this.getScope()) {
+        return (_base = this.__collections)[current_scope] || (_base[current_scope] = {});
+      } else {
+        return this.__collections;
+      }
+    };
+
+    CollectionManager.prototype.each = function(fn) {
+      return _(this.all()).each(fn);
+    };
+
+    CollectionManager.prototype.get = function(key) {
+      return this.currentScope()[key];
+    };
+
+    CollectionManager.prototype.getScope = function() {
+      return;
+    };
+
+    CollectionManager.prototype.getOrCreate = function(key, collectionOptions, initialModels) {
+      if (collectionOptions == null) collectionOptions = {};
+      if (initialModels == null) initialModels = [];
+      return this.get(key) || this.create(key, collectionOptions, initialModels, false);
+    };
+
+    CollectionManager.prototype.guessCollectionClass = function(key) {
+      var classified, guess;
+      classified = _(key).chain().capitalize().camelize().value();
+      guess = (this.collectionNamespace || (window || global))[classified];
+      return guess;
+    };
+
+    CollectionManager.prototype.private = function(key, collectionOptions, initialModels) {
+      if (collectionOptions == null) collectionOptions = {};
+      if (initialModels == null) initialModels = [];
+      return this.create(key, collectionOptions, initialModels, true);
+    };
+
+    return CollectionManager;
+
+  })();
+
+  Luca.CollectionManager.destroyAll = function() {
+    return instances = [];
+  };
+
+  Luca.CollectionManager.instances = function() {
+    return instances;
+  };
+
+  Luca.CollectionManager.get = function() {
+    return _(instances).last();
+  };
+
+}).call(this);

data/vendor/assets/luca-ui/managers/socket_manager.js

@@ -0,0 +1,52 @@
+(function() {
+
+  Luca.SocketManager = (function() {
+
+    function SocketManager(options) {
+      this.options = options != null ? options : {};
+      _.extend(Backbone.Events);
+      this.loadTransport();
+    }
+
+    SocketManager.prototype.connect = function() {
+      switch (this.options.provider) {
+        case "socket.io":
+          return this.socket = io.connect(this.options.socket_host);
+        case "faye.js":
+          return this.socket = new Faye.Client(this.options.socket_host);
+      }
+    };
+
+    SocketManager.prototype.transportLoaded = function() {
+      return this.connect();
+    };
+
+    SocketManager.prototype.transport_script = function() {
+      switch (this.options.provider) {
+        case "socket.io":
+          return "" + this.options.transport_host + "/socket.io/socket.io.js";
+        case "faye.js":
+          return "" + this.options.transport_host + "/faye.js";
+      }
+    };
+
+    SocketManager.prototype.loadTransport = function() {
+      var script,
+        _this = this;
+      script = document.createElement('script');
+      script.setAttribute("type", "text/javascript");
+      script.setAttribute("src", this.transport_script());
+      script.onload = this.transportLoaded;
+      if (Luca.util.isIE()) {
+        script.onreadystatechange = function() {
+          if (script.readyState === "loaded") return _this.transportLoaded();
+        };
+      }
+      return document.getElementsByTagName('head')[0].appendChild(script);
+    };
+
+    return SocketManager;
+
+  })();
+
+}).call(this);

data/vendor/assets/luca-ui/modules/deferrable.js

@@ -0,0 +1,21 @@
+(function() {
+
+  Luca.modules.Deferrable = {
+    configure_collection: function(setAsDeferrable) {
+      var collectionManager, _ref, _ref2;
+      if (setAsDeferrable == null) setAsDeferrable = true;
+      if (!this.collection) return;
+      if (_.isString(this.collection) && (collectionManager = (_ref = Luca.CollectionManager) != null ? _ref.get() : void 0)) {
+        this.collection = collectionManager.getOrCreate(this.collection);
+      }
+      if (!(this.collection && _.isFunction(this.collection.fetch) && _.isFunction(this.collection.reset))) {
+        this.collection = new Luca.Collection(this.collection.initial_set, this.collection);
+      }
+      if ((_ref2 = this.collection) != null ? _ref2.deferrable_trigger : void 0) {
+        this.deferrable_trigger = this.collection.deferrable_trigger;
+      }
+      if (setAsDeferrable) return this.deferrable = this.collection;
+    }
+  };
+
+}).call(this);

data/vendor/assets/luca-ui/modules/local_storage.js

@@ -0,0 +1,81 @@
+(function() {
+
+  Luca.LocalStore = (function() {
+
+    function LocalStore(name) {
+      var store;
+      this.name = name;
+      store = localStorage.getItem(this.name);
+      this.data = (store && JSON.parse(store)) || {};
+    }
+
+    LocalStore.prototype.guid = function() {
+      var S4;
+      S4 = function() {
+        return (((1 + Math.random()) * 0x10000) | 0).toString(16).substring(1);
+      };
+      return S4() + S4() + "-" + S4() + "-" + S4() + "-" + S4() + "-" + S4() + S4() + S4();
+    };
+
+    LocalStore.prototype.save = function() {
+      return localStorage.setItem(this.name, JSON.stringify(this.data));
+    };
+
+    LocalStore.prototype.create = function(model) {
+      if (!model.id) model.id = model.attribtues.id = this.guid();
+      this.data[model.id] = model;
+      this.save();
+      return model;
+    };
+
+    LocalStore.prototype.update = function(model) {
+      this.data[model.id] = model;
+      this.save();
+      return model;
+    };
+
+    LocalStore.prototype.find = function(model) {
+      return this.data[model.id];
+    };
+
+    LocalStore.prototype.findAll = function() {
+      return _.values(this.data);
+    };
+
+    LocalStore.prototype.destroy = function(model) {
+      delete this.data[model.id];
+      this.save();
+      return model;
+    };
+
+    return LocalStore;
+
+  })();
+
+  Backbone.LocalSync = function(method, model, options) {
+    var resp, store;
+    store = model.localStorage || model.collection.localStorage;
+    resp = (function() {
+      switch (method) {
+        case "read":
+          if (model.id) {
+            return store.find(model);
+          } else {
+            return store.findAll();
+          }
+        case "create":
+          return store.create(model);
+        case "update":
+          return store.update(model);
+        case "delete":
+          return store.destroy(model);
+      }
+    })();
+    if (resp) {
+      return options.success(resp);
+    } else {
+      return options.error("Record not found");
+    }
+  };
+
+}).call(this);