luca 0.9.9 → 0.9.42

data/vendor/assets/luca-ui/containers/viewport.js

@@ -0,0 +1,18 @@
+(function() {
+
+  Luca.containers.Viewport = Luca.containers.CardView.extend({
+    activeItem: 0,
+    className: 'luca-ui-viewport',
+    fullscreen: true,
+    initialize: function(options) {
+      this.options = options != null ? options : {};
+      Luca.core.Container.prototype.initialize.apply(this, arguments);
+      if (this.fullscreen) return $('html,body').addClass('luca-ui-fullscreen');
+    },
+    render: function() {
+      console.log("Rendering Viewport");
+      return this.$el.addClass('luca-ui-viewport');
+    }
+  });
+
+}).call(this);

data/vendor/assets/luca-ui/core/collection.js

@@ -0,0 +1,221 @@
+(function() {
+
+  Luca.Collection = (Backbone.QueryCollection || Backbone.Collection).extend({
+    initialize: function(models, options) {
+      var table,
+        _this = this;
+      if (models == null) models = [];
+      this.options = options;
+      _.extend(this, this.options);
+      if (this.cached) {
+        this.bootstrap_cache_key = _.isFunction(this.cached) ? this.cached() : this.cached;
+      }
+      if (this.registerAs || this.registerWith) {
+        console.log("This configuration API is deprecated.  use @name and @manager properties instead");
+      }
+      this.name || (this.name = this.registerAs);
+      this.manager || (this.manager = this.registerWith);
+      if (this.name && !this.manager) this.manager = Luca.CollectionManager.get();
+      if (this.manager) {
+        this.name || (this.name = this.cached());
+        this.name = _.isFunction(this.name) ? this.name() : this.name;
+        this.bind("after:initialize", function() {
+          return _this.register(_this.manager, _this.name, _this);
+        });
+      }
+      if (this.useLocalStorage === true && (window.localStorage != null)) {
+        table = this.bootstrap_cache_key || this.name;
+        throw "Must specify either a cached or registerAs property to use localStorage";
+        this.localStorage = new Luca.LocalStore(table);
+      }
+      if (_.isArray(this.data) && this.data.length > 0) {
+        this.memoryCollection = true;
+      }
+      if (this.useNormalUrl !== true) this.__wrapUrl();
+      Backbone.Collection.prototype.initialize.apply(this, [models, this.options]);
+      return this.trigger("after:initialize");
+    },
+    __wrapUrl: function() {
+      var params, url,
+        _this = this;
+      if (_.isFunction(this.url)) {
+        return this.url = _.wrap(this.url, function(fn) {
+          var existing_params, new_val, parts, queryString, val;
+          val = fn.apply(_this);
+          parts = val.split('?');
+          if (parts.length > 1) existing_params = _.last(parts);
+          queryString = _this.queryString();
+          if (existing_params && val.match(existing_params)) {
+            queryString = queryString.replace(existing_params, '');
+          }
+          new_val = "" + val + "?" + queryString;
+          if (new_val.match(/\?$/)) new_val = new_val.replace(/\?$/, '');
+          return new_val;
+        });
+      } else {
+        url = this.url;
+        params = this.queryString();
+        return this.url = _([url, params]).compact().join("?");
+      }
+    },
+    queryString: function() {
+      var parts,
+        _this = this;
+      parts = _(this.base_params || (this.base_params = Luca.Collection.baseParams())).inject(function(memo, value, key) {
+        var str;
+        str = "" + key + "=" + value;
+        memo.push(str);
+        return memo;
+      }, []);
+      return _.uniq(parts).join("&");
+    },
+    resetFilter: function() {
+      this.base_params = Luca.Collection.baseParams();
+      return this;
+    },
+    applyFilter: function(filter, options) {
+      if (filter == null) filter = {};
+      if (options == null) options = {};
+      this.applyParams(filter);
+      return this.fetch(_.extend(options, {
+        refresh: true
+      }));
+    },
+    applyParams: function(params) {
+      this.base_params || (this.base_params = Luca.Collection.baseParams());
+      return _.extend(this.base_params, params);
+    },
+    register: function(collectionManager, key, collection) {
+      if (collectionManager == null) {
+        collectionManager = Luca.CollectionManager.get();
+      }
+      if (key == null) key = "";
+      if (!(key.length >= 1)) {
+        throw "Can not register with a collection manager without a key";
+      }
+      if (collectionManager == null) {
+        throw "Can not register with a collection manager without a valid collection manager";
+      }
+      if (_.isString(collectionManager)) {
+        collectionManager = Luca.util.nestedValue(collectionManager, window || global);
+      }
+      if (!collectionManager) throw "Could not register with collection manager";
+      if (_.isFunction(collectionManager.add)) {
+        return collectionManager.add(key, collection);
+      }
+      if (_.isObject(collectionManager)) {
+        return collectionManager[key] = collection;
+      }
+    },
+    loadFromBootstrap: function() {
+      if (!this.bootstrap_cache_key) return;
+      this.reset(this.cached_models());
+      return this.trigger("bootstrapped", this);
+    },
+    bootstrap: function() {
+      return this.loadFromBootstrap();
+    },
+    cached_models: function() {
+      return Luca.Collection.cache(this.bootstrap_cache_key);
+    },
+    fetch: function(options) {
+      var url;
+      if (options == null) options = {};
+      this.trigger("before:fetch", this);
+      if (this.memoryCollection === true) return this.reset(this.data);
+      if (this.cached_models().length && !options.refresh) return this.bootstrap();
+      url = _.isFunction(this.url) ? this.url() : this.url;
+      if (!((url && url.length > 1) || this.localStorage)) return true;
+      this.fetching = true;
+      try {
+        return Backbone.Collection.prototype.fetch.apply(this, arguments);
+      } catch (e) {
+        console.log("Error in Collection.fetch", e);
+        throw e;
+      }
+    },
+    onceLoaded: function(fn, options) {
+      var wrapped,
+        _this = this;
+      if (options == null) {
+        options = {
+          autoFetch: true
+        };
+      }
+      if (this.length > 0 && !this.fetching) {
+        fn.apply(this, [this]);
+        return;
+      }
+      wrapped = function() {
+        return fn.apply(_this, [_this]);
+      };
+      this.bind("reset", function() {
+        wrapped();
+        return this.unbind("reset", this);
+      });
+      if (!(this.fetching || !options.autoFetch)) return this.fetch();
+    },
+    ifLoaded: function(fn, options) {
+      var scope,
+        _this = this;
+      if (options == null) {
+        options = {
+          scope: this,
+          autoFetch: true
+        };
+      }
+      scope = options.scope || this;
+      if (this.length > 0 && !this.fetching) fn.apply(scope, [this]);
+      this.bind("reset", function(collection) {
+        return fn.apply(scope, [collection]);
+      });
+      if (!(this.fetching === true || !options.autoFetch || this.length > 0)) {
+        return this.fetch();
+      }
+    },
+    parse: function(response) {
+      var models;
+      this.fetching = false;
+      this.trigger("after:response", response);
+      models = this.root != null ? response[this.root] : response;
+      if (this.bootstrap_cache_key) {
+        Luca.Collection.cache(this.bootstrap_cache_key, models);
+      }
+      return models;
+    }
+  });
+
+  _.extend(Luca.Collection.prototype, {
+    trigger: function() {
+      if (Luca.enableGlobalObserver) {
+        Luca.CollectionObserver || (Luca.CollectionObserver = new Luca.Observer({
+          type: "collection"
+        }));
+        Luca.CollectionObserver.relay(this, arguments);
+      }
+      return Backbone.View.prototype.trigger.apply(this, arguments);
+    }
+  });
+
+  Luca.Collection.baseParams = function(obj) {
+    if (obj) return Luca.Collection._baseParams = obj;
+    if (_.isFunction(Luca.Collection._baseParams)) {
+      return Luca.Collection._baseParams.call();
+    }
+    if (_.isObject(Luca.Collection._baseParams)) {
+      return Luca.Collection._baseParams;
+    }
+  };
+
+  Luca.Collection._bootstrapped_models = {};
+
+  Luca.Collection.bootstrap = function(obj) {
+    return _.extend(Luca.Collection._bootstrapped_models, obj);
+  };
+
+  Luca.Collection.cache = function(key, models) {
+    if (models) return Luca.Collection._bootstrapped_models[key] = models;
+    return Luca.Collection._bootstrapped_models[key] || [];
+  };
+
+}).call(this);

data/vendor/assets/luca-ui/core/container.js

@@ -0,0 +1,205 @@
+(function() {
+
+  Luca.core.Container = Luca.View.extend({
+    className: 'luca-ui-container',
+    componentClass: 'luca-ui-panel',
+    isContainer: true,
+    hooks: ["before:components", "before:layout", "after:components", "after:layout", "first:activation"],
+    rendered: false,
+    components: [],
+    initialize: function(options) {
+      this.options = options != null ? options : {};
+      _.extend(this, this.options);
+      this.setupHooks(Luca.core.Container.prototype.hooks);
+      return Luca.View.prototype.initialize.apply(this, arguments);
+    },
+    beforeRender: function() {
+      this.debug("container before render");
+      this.doLayout();
+      return this.doComponents();
+    },
+    doLayout: function() {
+      this.debug("container do layout");
+      this.trigger("before:layout", this);
+      this.prepareLayout();
+      return this.trigger("after:layout", this);
+    },
+    doComponents: function() {
+      this.debug("container do components");
+      this.trigger("before:components", this, this.components);
+      this.prepareComponents();
+      this.createComponents();
+      this.renderComponents();
+      return this.trigger("after:components", this, this.components);
+    },
+    applyPanelConfig: function(panel, panelIndex) {
+      var config, style_declarations;
+      style_declarations = [];
+      if (panel.height) {
+        style_declarations.push("height: " + (_.isNumber(panel.height) ? panel.height + 'px' : panel.height));
+      }
+      if (panel.width) {
+        style_declarations.push("width: " + (_.isNumber(panel.width) ? panel.width + 'px' : panel.width));
+      }
+      if (panel.float) style_declarations.push("float: " + panel.float);
+      return config = {
+        classes: (panel != null ? panel.classes : void 0) || this.componentClass,
+        id: "" + this.cid + "-" + panelIndex,
+        style: style_declarations.join(';')
+      };
+    },
+    prepareLayout: function() {
+      var _this = this;
+      this.debug("container prepare layout");
+      this.componentContainers = _(this.components).map(function(component, index) {
+        return _this.applyPanelConfig.apply(_this, [component, index]);
+      });
+      if (this.appendContainers) {
+        return _(this.componentContainers).each(function(container) {
+          return _this.$el.append(Luca.templates["containers/basic"](container));
+        });
+      }
+    },
+    prepareComponents: function() {
+      var _this = this;
+      this.debug("container prepare components");
+      return this.components = _(this.components).map(function(object, index) {
+        var panel;
+        panel = _this.componentContainers[index];
+        object.container = _this.appendContainers ? "#" + panel.id : _this.el;
+        return object;
+      });
+    },
+    createComponents: function() {
+      var map,
+        _this = this;
+      this.debug("container create components");
+      map = this.componentIndex = {
+        name_index: {},
+        cid_index: {}
+      };
+      this.components = _(this.components).map(function(object, index) {
+        var component;
+        component = _.isObject(object) && object.render && object.trigger ? object : (object.ctype || (object.ctype = Luca.defaultComponentType || "template"), Luca.util.lazyComponent(object));
+        if (!component.container && component.options.container) {
+          component.container = component.options.container;
+        }
+        if (map && (component.cid != null)) map.cid_index[component.cid] = index;
+        if (map && (component.name != null)) {
+          map.name_index[component.name] = index;
+        }
+        return component;
+      });
+      return this.debug("components created", this.components);
+    },
+    renderComponents: function(debugMode) {
+      var _this = this;
+      this.debugMode = debugMode != null ? debugMode : "";
+      this.debug("container render components");
+      return _(this.components).each(function(component) {
+        component.getParent = function() {
+          return _this;
+        };
+        $(component.container).append($(component.el));
+        try {
+          return component.render();
+        } catch (e) {
+          console.log("Error Rendering Component " + (component.name || component.cid), component);
+          console.log(e.message);
+          return console.log(e.stack);
+        }
+      });
+    },
+    firstActivation: function() {
+      var _this = this;
+      return _(this.components).each(function(component) {
+        var activator, _ref;
+        activator = _this;
+        if ((component != null ? component.previously_activated : void 0) !== true) {
+          if (component != null) {
+            if ((_ref = component.trigger) != null) {
+              _ref.apply(component, ["first:activation", [component, activator]]);
+            }
+          }
+          return component.previously_activated = true;
+        }
+      });
+    },
+    select: function(attribute, value, deep) {
+      var components;
+      if (deep == null) deep = false;
+      components = _(this.components).map(function(component) {
+        var matches, test;
+        matches = [];
+        test = component[attribute];
+        if (test === value) matches.push(component);
+        if (deep === true && component.isContainer === true) {
+          matches.push(component.select(attribute, value, true));
+        }
+        return _.compact(matches);
+      });
+      return _.flatten(components);
+    },
+    findComponentByName: function(name, deep) {
+      if (deep == null) deep = false;
+      return this.findComponent(name, "name_index", deep);
+    },
+    findComponentById: function(id, deep) {
+      if (deep == null) deep = false;
+      return this.findComponent(id, "cid_index", deep);
+    },
+    findComponent: function(needle, haystack, deep) {
+      var component, position, sub_container, _ref, _ref2;
+      if (haystack == null) haystack = "name";
+      if (deep == null) deep = false;
+      position = (_ref = this.componentIndex) != null ? _ref[haystack][needle] : void 0;
+      component = (_ref2 = this.components) != null ? _ref2[position] : void 0;
+      if (component) return component;
+      if (deep === true) {
+        sub_container = _(this.components).detect(function(component) {
+          return component != null ? typeof component.findComponent === "function" ? component.findComponent(needle, haystack, true) : void 0 : void 0;
+        });
+        return sub_container != null ? typeof sub_container.findComponent === "function" ? sub_container.findComponent(needle, haystack, true) : void 0 : void 0;
+      }
+    },
+    eachComponent: function(fn, deep) {
+      var _this = this;
+      if (deep == null) deep = true;
+      return _(this.components).each(function(component) {
+        var _ref;
+        fn.apply(component, [component]);
+        if (deep) {
+          return component != null ? (_ref = component.eachComponent) != null ? _ref.apply(component, [fn, deep]) : void 0 : void 0;
+        }
+      });
+    },
+    indexOf: function(name) {
+      var names;
+      names = _(this.components).pluck('name');
+      return _(names).indexOf(name);
+    },
+    activeComponent: function() {
+      if (!this.activeItem) return this;
+      return this.components[this.activeItem];
+    },
+    componentElements: function() {
+      return $("." + this.componentClass, this.el);
+    },
+    getComponent: function(needle) {
+      return this.components[needle];
+    },
+    rootComponent: function() {
+      return !(this.getParent != null);
+    },
+    getRootComponent: function() {
+      if (this.rootComponent()) {
+        return this;
+      } else {
+        return this.getParent().getRootComponent();
+      }
+    }
+  });
+
+  Luca.register("container", "Luca.core.Container");
+
+}).call(this);

data/vendor/assets/luca-ui/core/field.js

@@ -0,0 +1,59 @@
+(function() {
+
+  Luca.core.Field = Luca.View.extend({
+    className: 'luca-ui-text-field luca-ui-field',
+    isField: true,
+    template: 'fields/text_field',
+    labelAlign: 'top',
+    hooks: ["before:validation", "after:validation", "on:change"],
+    statuses: ["warning", "error", "success"],
+    initialize: function(options) {
+      var _ref;
+      this.options = options != null ? options : {};
+      _.extend(this, this.options);
+      Luca.View.prototype.initialize.apply(this, arguments);
+      this.input_id || (this.input_id = _.uniqueId('field'));
+      this.input_name || (this.input_name = this.name);
+      this.helperText || (this.helperText = "");
+      if (this.required && !((_ref = this.label) != null ? _ref.match(/^\*/) : void 0)) {
+        this.label || (this.label = "*" + this.label);
+      }
+      this.inputStyles || (this.inputStyles = "");
+      if (this.disabled) this.disable();
+      this.updateState(this.state);
+      return this.placeHolder || (this.placeHolder = "");
+    },
+    beforeRender: function() {
+      if (Luca.enableBootstrap) this.$el.addClass('control-group');
+      if (this.required) this.$el.addClass('required');
+      this.$el.html(Luca.templates[this.template](this));
+      return this.input = $('input', this.el);
+    },
+    change_handler: function(e) {
+      return this.trigger("on:change", this, e);
+    },
+    disable: function() {
+      return $("input", this.el).attr('disabled', true);
+    },
+    enable: function() {
+      return $("input", this.el).attr('disabled', false);
+    },
+    getValue: function() {
+      return this.input.attr('value');
+    },
+    render: function() {
+      return $(this.container).append(this.$el);
+    },
+    setValue: function(value) {
+      return this.input.attr('value', value);
+    },
+    updateState: function(state) {
+      var _this = this;
+      return _(this.statuses).each(function(cls) {
+        _this.$el.removeClass(cls);
+        return _this.$el.addClass(state);
+      });
+    }
+  });
+
+}).call(this);

data/vendor/assets/luca-ui/core/observer.js

@@ -0,0 +1,42 @@
+(function() {
+  var __slice = Array.prototype.slice;
+
+  Luca.Observer = (function() {
+
+    function Observer(options) {
+      var _this = this;
+      this.options = options != null ? options : {};
+      _.extend(this, Backbone.Events);
+      this.type = this.options.type;
+      if (this.options.debugAll) {
+        this.bind("event", function() {
+          var args, t;
+          t = arguments[0], args = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+          return console.log("Observed " + _this.type + " " + (t.name || t.id || t.cid), t, _(args).flatten());
+        });
+      }
+    }
+
+    Observer.prototype.relay = function() {
+      var args, triggerer;
+      triggerer = arguments[0], args = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+      this.trigger("event", triggerer, args);
+      return this.trigger("event:" + args[0], triggerer, args.slice(1));
+    };
+
+    return Observer;
+
+  })();
+
+  Luca.Observer.enableObservers = function(options) {
+    if (options == null) options = {};
+    Luca.enableGlobalObserver = true;
+    Luca.ViewObserver = new Luca.Observer(_.extend(options, {
+      type: "view"
+    }));
+    return Luca.CollectionObserver = new Luca.Observer(_.extend(options, {
+      type: "collection"
+    }));
+  };
+
+}).call(this);

data/vendor/assets/luca-ui/core/view.js

@@ -0,0 +1,127 @@
+(function() {
+
+  Luca.View = Backbone.View.extend({
+    base: 'Luca.View'
+  });
+
+  Luca.View.originalExtend = Backbone.View.extend;
+
+  Luca.View.extend = function(definition) {
+    var _base;
+    _base = definition.render;
+    _base || (_base = function() {
+      var container;
+      container = _.isFunction(this.container) ? this.container() : this.container;
+      if (!($(container) && this.$el)) return this;
+      $(container).append(this.$el);
+      return this;
+    });
+    definition.render = function() {
+      var _this = this;
+      if (this.deferrable) {
+        this.trigger("before:render", this);
+        this.deferrable.bind(this.deferrable_event, _.once(function() {
+          _base.apply(_this, arguments);
+          return _this.trigger("after:render", _this);
+        }));
+        if (!this.deferrable_trigger) this.immediate_trigger = true;
+        if (this.immediate_trigger === true) {
+          return this.deferrable.fetch();
+        } else {
+          return this.bind(this.deferrable_trigger, _.once(function() {
+            return _this.deferrable.fetch();
+          }));
+        }
+      } else {
+        this.trigger("before:render", this);
+        _base.apply(this, arguments);
+        return this.trigger("after:render", this);
+      }
+    };
+    return Luca.View.originalExtend.apply(this, [definition]);
+  };
+
+  _.extend(Luca.View.prototype, {
+    debug: function() {
+      var message, _i, _len, _results;
+      if (!(this.debugMode || (window.LucaDebugMode != null))) return;
+      _results = [];
+      for (_i = 0, _len = arguments.length; _i < _len; _i++) {
+        message = arguments[_i];
+        _results.push(console.log([this.name || this.cid, message]));
+      }
+      return _results;
+    },
+    trigger: function() {
+      if (Luca.enableGlobalObserver) {
+        Luca.ViewObserver || (Luca.ViewObserver = new Luca.Observer({
+          type: "view"
+        }));
+        Luca.ViewObserver.relay(this, arguments);
+      }
+      return Backbone.View.prototype.trigger.apply(this, arguments);
+    },
+    hooks: ["after:initialize", "before:render", "after:render", "first:activation", "activation", "deactivation"],
+    deferrable_event: "reset",
+    initialize: function(options) {
+      var unique,
+        _this = this;
+      this.options = options != null ? options : {};
+      _.extend(this, this.options);
+      if (this.name != null) this.cid = _.uniqueId(this.name);
+      Luca.cache(this.cid, this);
+      unique = _(Luca.View.prototype.hooks.concat(this.hooks)).uniq();
+      this.setupHooks(unique);
+      if (this.autoBindEventHandlers === true) {
+        _(this.events).each(function(handler, event) {
+          if (_.isString(handler)) return _.bindAll(_this, handler);
+        });
+      }
+      this.trigger("after:initialize", this);
+      return this.registerCollectionEvents();
+    },
+    $container: function() {
+      return $(this.container);
+    },
+    setupHooks: function(set) {
+      var _this = this;
+      set || (set = this.hooks);
+      return _(set).each(function(event) {
+        var fn, parts, prefix;
+        parts = event.split(':');
+        prefix = parts.shift();
+        parts = _(parts).map(function(p) {
+          return _.capitalize(p);
+        });
+        fn = prefix + parts.join('');
+        return _this.bind(event, function() {
+          if (_this[fn]) return _this[fn].apply(_this, arguments);
+        });
+      });
+    },
+    getCollectionManager: function() {
+      var _ref;
+      return this.collectionManager || ((_ref = Luca.CollectionManager.get) != null ? _ref.call() : void 0);
+    },
+    registerCollectionEvents: function() {
+      var manager,
+        _this = this;
+      manager = this.getCollectionManager();
+      return _(this.collectionEvents).each(function(handler, signature) {
+        var collection, event, key, _ref;
+        _ref = signature.split(" "), key = _ref[0], event = _ref[1];
+        collection = _this["" + key + "Collection"] = manager.getOrCreate(key);
+        if (!collection) throw "Could not find collection specified by " + key;
+        if (_.isString(handler)) handler = _this[handler];
+        if (!_.isFunction(handler)) throw "invalid collectionEvents configuration";
+        try {
+          return collection.bind(event, handler);
+        } catch (e) {
+          console.log("Error Binding To Collection in registerCollectionEvents", _this);
+          throw e;
+        }
+      });
+    }
+  });
+
+}).call(this);