luca 0.6.6

data/vendor/assets/luca-ui/base.css

@@ -0,0 +1,85 @@
+html.luca-ui-fullscreen {
+  height: 100%; }
+  html.luca-ui-fullscreen body {
+    height: 100%;
+    padding: 0;
+    margin: 0; }
+  html.luca-ui-fullscreen .luca-ui-viewport {
+    height: 100%;
+    padding: 0;
+    margin: 0; }
+
+.luca-ui-viewport li {
+  list-style-type: none; }
+.luca-ui-viewport li.nav {
+  cursor: pointer; }
+
+/*http://csswizardry.com/fluid-grids/#generated-grids*/
+.wrapper {
+  max-width: 1208px;
+  /*  max-width:894px;*/
+  padding: 0 15px;
+  margin: 0 auto; }
+
+/*
+Column container
+*/
+.grids {
+  width: auto;
+  max-width: 924px;
+  clear: both;
+  margin: 0 0 0 -3.247%;
+  list-style: none;
+  /* So we can make grids out of lists. */
+  overflow: hidden;
+  /* Clear the floats */ }
+
+[class*="grid-"] {
+  float: left;
+  margin: 0 3.247% 0 0; }
+
+.grid-margin {
+  margin: 0 3.247% 0 0; }
+
+.grids .grid-margin {
+  margin: 0 0 0 3.247%; }
+
+.grids [class*="grid-"] {
+  margin: 0 0 0 3.247%; }
+
+.grid-1 {
+  width: 5.087%; }
+
+.grid-2 {
+  width: 13.42%; }
+
+.grid-3 {
+  width: 21.753%; }
+
+.grid-4 {
+  width: 30.087%; }
+
+.grid-5 {
+  width: 38.42%; }
+
+.grid-6 {
+  width: 46.753%; }
+
+.grid-7 {
+  width: 55.087%; }
+
+.grid-8 {
+  width: 63.42%; }
+
+.grid-9 {
+  width: 71.753%; }
+
+.grid-10 {
+  width: 80.087%; }
+
+.grid-11 {
+  width: 88.42%; }
+
+.grid-12 {
+  width: 96.753%;
+  margin: 0; }

data/vendor/assets/luca-ui/components/application.js

@@ -0,0 +1,91 @@
+(function() {
+
+  Luca.Application = Luca.containers.Viewport.extend({
+    components: [
+      {
+        ctype: 'controller',
+        name: 'main_controller',
+        defaultCard: 'welcome',
+        components: [
+          {
+            ctype: 'template',
+            name: 'welcome',
+            template: 'sample/welcome',
+            templateContainer: "Luca.templates"
+          }
+        ]
+      }
+    ],
+    initialize: function(options) {
+      var _this = this;
+      this.options = options != null ? options : {};
+      Luca.containers.Viewport.prototype.initialize.apply(this, arguments);
+      this.collectionManager = new Luca.CollectionManager();
+      this.state = new Backbone.Model(this.defaultState);
+      return this.bind("ready", function() {
+        return _this.render();
+      });
+    },
+    activeView: function() {
+      var active;
+      if (active = this.activeSubSection()) {
+        return this.view(active);
+      } else {
+        return this.view(this.activeSection());
+      }
+    },
+    activeSubSection: function() {
+      return this.get("active_sub_section");
+    },
+    activeSection: function() {
+      return this.get("active_section");
+    },
+    afterComponents: function() {
+      var _ref, _ref2, _ref3,
+        _this = this;
+      if ((_ref = Luca.containers.Viewport.prototype.afterComponents) != null) {
+        _ref.apply(this, arguments);
+      }
+      if ((_ref2 = this.getMainController()) != null) {
+        _ref2.bind("after:card:switch", function(previous, current) {
+          return _this.state.set({
+            active_section: current.name
+          });
+        });
+      }
+      return (_ref3 = this.getMainController()) != null ? _ref3.each(function(component) {
+        if (component.ctype.match(/controller$/)) {
+          return component.bind("after:card:switch", function(previous, current) {
+            return _this.state.set({
+              active_sub_section: current.name
+            });
+          });
+        }
+      }) : void 0;
+    },
+    beforeRender: function() {
+      var _ref;
+      return (_ref = Luca.containers.Viewport.prototype.beforeRender) != null ? _ref.apply(this, arguments) : void 0;
+    },
+    boot: function() {
+      console.log("Sup?");
+      return this.trigger("ready");
+    },
+    collection: function() {
+      return this.collectionManager.getOrCreate.apply(this.collectionManager, arguments);
+    },
+    get: function(attribute) {
+      return this.state.get(attribute);
+    },
+    getMainController: function() {
+      return this.view("main_controler");
+    },
+    set: function(attributes) {
+      return this.state.set(attributes);
+    },
+    view: function(name) {
+      return Luca.cache(name);
+    }
+  });
+
+}).call(this);

data/vendor/assets/luca-ui/components/base_toolbar.js

@@ -0,0 +1,23 @@
+(function() {
+
+  Luca.components.Toolbar = Luca.core.Container.extend({
+    className: 'luca-ui-toolbar',
+    position: 'bottom',
+    initialize: function(options) {
+      this.options = options != null ? options : {};
+      return Luca.core.Container.prototype.initialize.apply(this, arguments);
+    },
+    prepareComponents: function() {
+      var _this = this;
+      return _(this.components).each(function(component) {
+        return component.container = _this.el;
+      });
+    },
+    render: function() {
+      return $(this.container).append(this.el);
+    }
+  });
+
+  Luca.register("toolbar", "Luca.components.Toolbar");
+
+}).call(this);

data/vendor/assets/luca-ui/components/controller.js

@@ -0,0 +1,38 @@
+(function() {
+
+  Luca.components.Controller = Luca.containers.CardView.extend({
+    initialize: function(options) {
+      var _ref;
+      this.options = options;
+      Luca.containers.CardView.prototype.initialize.apply(this, arguments);
+      this.defaultCard || (this.defaultCard = (_ref = this.components[0]) != null ? _ref.name : void 0);
+      if (!this.defaultCard) {
+        throw "Controllers must specify a defaultCard property and/or the first component must have a name";
+      }
+      return this.state = new Backbone.Model({
+        active_section: this.defaultCard
+      });
+    },
+    each: function(fn) {
+      var _this = this;
+      return _(this.components).each(function(component) {
+        return fn.apply(_this, [component]);
+      });
+    },
+    "default": function(callback) {
+      return this.navigate_to(this.defaultCard, callback);
+    },
+    navigate_to: function(section, callback) {
+      var _this = this;
+      section || (section = this.defaultCard);
+      this.activate(section, false, function(activator, previous, current) {
+        _this.state.set({
+          active_section: current.name
+        });
+        if (_.isFunction(callback)) return callback.apply(current);
+      });
+      return this.find(section);
+    }
+  });
+
+}).call(this);

data/vendor/assets/luca-ui/components/fields/button_field.js

@@ -0,0 +1,45 @@
+(function() {
+
+  Luca.fields.ButtonField = Luca.core.Field.extend({
+    form_field: true,
+    readOnly: true,
+    events: {
+      "click input": "click_handler"
+    },
+    hooks: ["button:click"],
+    className: 'luca-ui-field luca-ui-button-field',
+    template: 'fields/button_field',
+    click_handler: function(e) {
+      var me, my;
+      me = my = $(e.currentTarget);
+      return this.trigger("button:click");
+    },
+    initialize: function(options) {
+      var _ref;
+      this.options = options != null ? options : {};
+      _.extend(this.options);
+      _.bindAll(this, "click_handler");
+      Luca.core.Field.prototype.initialize.apply(this, arguments);
+      if ((_ref = this.icon_class) != null ? _ref.length : void 0) {
+        return this.template = "fields/button_field_link";
+      }
+    },
+    afterInitialize: function() {
+      this.input_id || (this.input_id = _.uniqueId('button'));
+      this.input_name || (this.input_name = this.name || (this.name = this.input_id));
+      this.input_value || (this.input_value = this.label || (this.label = this.text));
+      this.input_type || (this.input_type = "button");
+      this.input_class || (this.input_class = this["class"]);
+      this.icon_class || (this.icon_class = "");
+      if (this.icon_class.length && !this.icon_class.match(/^icon-/)) {
+        return this.icon_class = "icon-" + this.icon_class;
+      }
+    },
+    setValue: function() {
+      return true;
+    }
+  });
+
+  Luca.register("button_field", "Luca.fields.ButtonField");
+
+}).call(this);

data/vendor/assets/luca-ui/components/fields/checkbox_field.js

@@ -0,0 +1,43 @@
+(function() {
+
+  Luca.fields.CheckboxField = Luca.core.Field.extend({
+    form_field: true,
+    events: {
+      "change input": "change_handler"
+    },
+    change_handler: function(e) {
+      var me, my;
+      me = my = $(e.currentTarget);
+      this.trigger("on:change", this, e);
+      if (me.checked === true) {
+        return this.trigger("checked");
+      } else {
+        return this.trigger("unchecked");
+      }
+    },
+    className: 'luca-ui-checkbox-field luca-ui-field',
+    template: 'fields/checkbox_field',
+    hooks: ["checked", "unchecked"],
+    initialize: function(options) {
+      this.options = options != null ? options : {};
+      _.extend(this, this.options);
+      _.bindAll(this, "change_handler");
+      return Luca.core.Field.prototype.initialize.apply(this, arguments);
+    },
+    afterInitialize: function() {
+      this.input_id || (this.input_id = _.uniqueId('field'));
+      this.input_name || (this.input_name = this.name);
+      this.input_value || (this.input_value = 1);
+      return this.label || (this.label = this.name);
+    },
+    setValue: function(checked) {
+      return this.input.attr('checked', checked);
+    },
+    getValue: function() {
+      return this.input.attr('checked') === true;
+    }
+  });
+
+  Luca.register("checkbox_field", "Luca.fields.CheckboxField");
+
+}).call(this);

data/vendor/assets/luca-ui/components/fields/file_upload_field.js

@@ -0,0 +1,20 @@
+(function() {
+
+  Luca.fields.FileUploadField = Luca.core.Field.extend({
+    form_field: true,
+    template: 'fields/file_upload_field',
+    initialize: function(options) {
+      this.options = options != null ? options : {};
+      return Luca.core.Field.prototype.initialize.apply(this, arguments);
+    },
+    afterInitialize: function() {
+      this.input_id || (this.input_id = _.uniqueId('field'));
+      this.input_name || (this.input_name = this.name);
+      this.label || (this.label = this.name);
+      return this.helperText || (this.helperText = "");
+    }
+  });
+
+  Luca.register("file_upload_field", "Luca.fields.FileUploadField");
+
+}).call(this);

data/vendor/assets/luca-ui/components/fields/hidden_field.js

@@ -0,0 +1,20 @@
+(function() {
+
+  Luca.fields.HiddenField = Luca.core.Field.extend({
+    form_field: true,
+    template: 'fields/hidden_field',
+    initialize: function(options) {
+      this.options = options != null ? options : {};
+      return Luca.core.Field.prototype.initialize.apply(this, arguments);
+    },
+    afterInitialize: function() {
+      this.input_id || (this.input_id = _.uniqueId('field'));
+      this.input_name || (this.input_name = this.name);
+      this.input_value || (this.input_value = this.value);
+      return this.label || (this.label = this.name);
+    }
+  });
+
+  Luca.register("hidden_field", "Luca.fields.HiddenField");
+
+}).call(this);

data/vendor/assets/luca-ui/components/fields/select_field.js

@@ -0,0 +1,97 @@
+(function() {
+
+  Luca.fields.SelectField = Luca.core.Field.extend({
+    form_field: true,
+    events: {
+      "change select": "change_handler"
+    },
+    hooks: ["after:select"],
+    className: 'luca-ui-select-field luca-ui-field',
+    template: "fields/select_field",
+    includeBlank: true,
+    blankValue: '',
+    blankText: 'Select One',
+    initialize: function(options) {
+      this.options = options != null ? options : {};
+      _.extend(this, this.options);
+      _.extend(this, Luca.modules.Deferrable);
+      _.bindAll(this, "change_handler", "populateOptions", "beforeFetch");
+      Luca.core.Field.prototype.initialize.apply(this, arguments);
+      this.input_id || (this.input_id = _.uniqueId('field'));
+      this.input_name || (this.input_name = this.name);
+      this.label || (this.label = this.name);
+      if (_.isUndefined(this.retainValue)) return this.retainValue = true;
+    },
+    afterInitialize: function() {
+      var _ref;
+      if ((_ref = this.collection) != null ? _ref.data : void 0) {
+        this.valueField || (this.valueField = "id");
+        this.displayField || (this.displayField = "name");
+        this.parseData();
+      }
+      try {
+        this.configure_collection();
+      } catch (e) {
+        console.log("Error Configuring Collection", this, e.message);
+      }
+      this.collection.bind("before:fetch", this.beforeFetch);
+      return this.collection.bind("reset", this.populateOptions);
+    },
+    parseData: function() {
+      var _this = this;
+      return this.collection.data = _(this.collection.data).map(function(record) {
+        var hash;
+        if (!_.isArray(record)) return record;
+        hash = {};
+        hash[_this.valueField] = record[0];
+        hash[_this.displayField] = record[1];
+        return hash;
+      });
+    },
+    afterRender: function() {
+      var _ref, _ref2;
+      this.input = $('select', this.el);
+      if (((_ref = this.collection) != null ? (_ref2 = _ref.models) != null ? _ref2.length : void 0 : void 0) > 0) {
+        return this.populateOptions();
+      } else {
+        return this.collection.trigger("reset");
+      }
+    },
+    setValue: function(value) {
+      this.currentValue = value;
+      return Luca.core.Field.prototype.setValue.apply(this, arguments);
+    },
+    beforeFetch: function() {
+      return this.resetOptions();
+    },
+    change_handler: function(e) {
+      return this.trigger("on:change", this, e);
+    },
+    resetOptions: function() {
+      this.input.html('');
+      if (this.includeBlank) {
+        return this.input.append("<option value='" + this.blankValue + "'>" + this.blankText + "</option>");
+      }
+    },
+    populateOptions: function() {
+      var _ref,
+        _this = this;
+      this.resetOptions();
+      if (((_ref = this.collection) != null ? _ref.each : void 0) != null) {
+        this.collection.each(function(model) {
+          var display, option, selected, value;
+          value = model.get(_this.valueField);
+          display = model.get(_this.displayField);
+          if (_this.selected && value === _this.selected) selected = "selected";
+          option = "<option " + selected + " value='" + value + "'>" + display + "</option>";
+          return _this.input.append(option);
+        });
+      }
+      this.trigger("after:populate:options", this);
+      return this.setValue(this.currentValue);
+    }
+  });
+
+  Luca.register("select_field", "Luca.fields.SelectField");
+
+}).call(this);

data/vendor/assets/luca-ui/components/fields/text_area_field.js

@@ -0,0 +1,48 @@
+(function() {
+
+  Luca.fields.TextAreaField = Luca.core.Field.extend({
+    form_field: true,
+    events: {
+      "keydown input": "keydown_handler",
+      "blur input": "blur_handler",
+      "focus input": "focus_handler"
+    },
+    template: 'fields/text_area_field',
+    height: "200px",
+    width: "90%",
+    initialize: function(options) {
+      this.options = options != null ? options : {};
+      _.bindAll(this, "keydown_handler");
+      Luca.core.Field.prototype.initialize.apply(this, arguments);
+      this.input_id || (this.input_id = _.uniqueId('field'));
+      this.input_name || (this.input_name = this.name);
+      this.label || (this.label = this.name);
+      this.input_class || (this.input_class = this["class"]);
+      return this.inputStyles || (this.inputStyles = "height:" + this.height + ";width:" + this.width);
+    },
+    setValue: function(value) {
+      return $(this.field()).val(value);
+    },
+    getValue: function() {
+      return $(this.field()).val();
+    },
+    field: function() {
+      return this.input = $("textarea#" + this.input_id, this.el);
+    },
+    keydown_handler: function(e) {
+      var me, my;
+      return me = my = $(e.currentTarget);
+    },
+    blur_handler: function(e) {
+      var me, my;
+      return me = my = $(e.currentTarget);
+    },
+    focus_handler: function(e) {
+      var me, my;
+      return me = my = $(e.currentTarget);
+    }
+  });
+
+  Luca.register("text_area_field", "Luca.fields.TextAreaField");
+
+}).call(this);

data/vendor/assets/luca-ui/components/fields/text_field.js

@@ -0,0 +1,46 @@
+(function() {
+
+  Luca.fields.TextField = Luca.core.Field.extend({
+    form_field: true,
+    events: {
+      "keydown input": "keydown_handler",
+      "blur input": "blur_handler",
+      "focus input": "focus_handler",
+      "change input": "change_handler"
+    },
+    template: 'fields/text_field',
+    initialize: function(options) {
+      this.options = options != null ? options : {};
+      _.bindAll(this, "keydown_handler", "blur_handler", "focus_handler");
+      Luca.core.Field.prototype.initialize.apply(this, arguments);
+      this.input_id || (this.input_id = _.uniqueId('field'));
+      this.input_name || (this.input_name = this.name);
+      this.label || (this.label = this.name);
+      if (this.prepend) {
+        this.$el.addClass('input-prepend');
+        this.addOn = this.prepend;
+      }
+      if (this.append) {
+        this.$el.addClass('input-append');
+        return this.addOn = this.append;
+      }
+    },
+    keydown_handler: _.throttle((function(e) {
+      return this.change_handler.apply(this, arguments);
+    }), 300),
+    blur_handler: function(e) {
+      var me, my;
+      return me = my = $(e.currentTarget);
+    },
+    focus_handler: function(e) {
+      var me, my;
+      return me = my = $(e.currentTarget);
+    },
+    change_handler: function(e) {
+      return this.trigger("on:change", this, e);
+    }
+  });
+
+  Luca.register("text_field", "Luca.fields.TextField");
+
+}).call(this);

data/vendor/assets/luca-ui/components/fields/type_ahead_field.js

@@ -0,0 +1,13 @@
+(function() {
+
+  Luca.fields.TypeAheadField = Luca.fields.TextField.extend({
+    form_field: true,
+    className: 'luca-ui-field',
+    afterInitialize: function() {
+      this.input_id || (this.input_id = _.uniqueId('field'));
+      this.input_name || (this.input_name = this.name);
+      return this.label || (this.label = this.name);
+    }
+  });
+
+}).call(this);

data/vendor/assets/luca-ui/components/form_button_toolbar.js

@@ -0,0 +1,32 @@
+(function() {
+
+  Luca.components.FormButtonToolbar = Luca.components.Toolbar.extend({
+    className: 'luca-ui-form-toolbar form-actions',
+    position: 'bottom',
+    includeReset: false,
+    render: function() {
+      return $(this.container).append(this.el);
+    },
+    initialize: function(options) {
+      this.options = options != null ? options : {};
+      Luca.components.Toolbar.prototype.initialize.apply(this, arguments);
+      this.components = [
+        {
+          ctype: 'button_field',
+          label: 'Submit',
+          "class": 'btn submit-button'
+        }
+      ];
+      if (this.includeReset) {
+        return this.components.push({
+          ctype: 'button_field',
+          label: 'Reset',
+          "class": 'btn reset-button'
+        });
+      }
+    }
+  });
+
+  Luca.register("form_button_toolbar", "Luca.components.FormButtonToolbar");
+
+}).call(this);

data/vendor/assets/luca-ui/components/form_view.css

@@ -0,0 +1,32 @@
+.luca-ui-form-view-wrapper {
+  width: 100%;
+  float: left;
+  display: block;
+  clear: both;
+  margin: 10px 0px; }
+
+.luca-ui-form-view .luca-ui-field {
+  margin: 5px;
+  padding: 5px; }
+  .luca-ui-form-view .luca-ui-field .helper-text {
+    font-size: 0.75em;
+    font-color: #ccc; }
+
+.luca-ui-form-view.label-align-top .luca-ui-field label, .luca-ui-form-view.label-align-top .luca-ui-field input, .luca-ui-form-view.label-align-top .luca-ui-field select, .luca-ui-form-view.label-align-top .luca-ui-field textarea {
+  margin: 5px 0px;
+  display: block; }
+
+.luca-ui-form-view.column-layout .luca-ui-field {
+  float: left; }
+
+.form-view-footer .toolbar-container {
+  float: left;
+  width: 100%;
+  clear: both;
+  display: block; }
+  .form-view-footer .toolbar-container .luca-ui-form-toolbar, .form-view-footer .toolbar-container .luca-ui-toolbar {
+    width: 50%;
+    display: block;
+    margin: 0px auto; }
+    .form-view-footer .toolbar-container .luca-ui-form-toolbar .luca-ui-field, .form-view-footer .toolbar-container .luca-ui-toolbar .luca-ui-field {
+      float: left; }