luca 0.9.9 → 0.9.42

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

@@ -0,0 +1,207 @@
+(function() {
+
+  Luca.components.RecordManager = Luca.containers.CardView.extend({
+    events: {
+      "click .record-manager-grid .edit-link": "edit_handler",
+      "click .record-manager-filter .filter-button": "filter_handler",
+      "click .record-manager-filter .reset-button": "reset_filter_handler",
+      "click .add-button": "add_handler",
+      "click .refresh-button": "filter_handler",
+      "click .back-to-search-button": "back_to_search_handler"
+    },
+    record_manager: true,
+    initialize: function(options) {
+      var _this = this;
+      this.options = options != null ? options : {};
+      Luca.containers.CardView.prototype.initialize.apply(this, arguments);
+      if (!this.name) throw "Record Managers must specify a name";
+      _.bindAll(this, "add_handler", "edit_handler", "filter_handler", "reset_filter_handler");
+      if (this.filterConfig) _.extend(this.components[0][0], this.filterConfig);
+      if (this.gridConfig) _.extend(this.components[0][1], this.gridConfig);
+      if (this.editorConfig) _.extend(this.components[1][0], this.editorConfig);
+      return this.bind("after:card:switch", function() {
+        if (_this.activeCard === 0) _this.trigger("activation:search", _this);
+        if (_this.activeCard === 1) {
+          return _this.trigger("activation:editor", _this);
+        }
+      });
+    },
+    components: [
+      {
+        ctype: 'split_view',
+        relayFirstActivation: true,
+        components: [
+          {
+            ctype: 'form_view'
+          }, {
+            ctype: 'grid_view'
+          }
+        ]
+      }, {
+        ctype: 'form_view'
+      }
+    ],
+    getSearch: function(activate, reset) {
+      if (activate == null) activate = false;
+      if (reset == null) reset = true;
+      if (activate === true) this.activate(0);
+      if (reset === true) this.getEditor().clear();
+      return _.first(this.components);
+    },
+    getFilter: function() {
+      return _.first(this.getSearch().components);
+    },
+    getGrid: function() {
+      return _.last(this.getSearch().components);
+    },
+    getCollection: function() {
+      return this.getGrid().collection;
+    },
+    getEditor: function(activate, reset) {
+      var _this = this;
+      if (activate == null) activate = false;
+      if (reset == null) reset = false;
+      if (activate === true) {
+        this.activate(1, function(activator, previous, current) {
+          return current.reset();
+        });
+      }
+      return _.last(this.components);
+    },
+    beforeRender: function() {
+      var _ref;
+      this.$el.addClass("" + this.resource + "-manager");
+      if ((_ref = Luca.containers.CardView.prototype.beforeRender) != null) {
+        _ref.apply(this, arguments);
+      }
+      this.$el.addClass("" + this.resource + " record-manager");
+      this.$el.data('resource', this.resource);
+      $(this.getGrid().el).addClass("" + this.resource + " record-manager-grid");
+      $(this.getFilter().el).addClass("" + this.resource + " record-manager-filter");
+      return $(this.getEditor().el).addClass("" + this.resource + " record-manager-editor");
+    },
+    afterRender: function() {
+      var collection, editor, filter, grid, manager, _ref,
+        _this = this;
+      if ((_ref = Luca.containers.CardView.prototype.afterRender) != null) {
+        _ref.apply(this, arguments);
+      }
+      manager = this;
+      grid = this.getGrid();
+      filter = this.getFilter();
+      editor = this.getEditor();
+      collection = this.getCollection();
+      grid.bind("row:double:click", function(grid, model, index) {
+        manager.getEditor(true);
+        return editor.loadModel(model);
+      });
+      editor.bind("before:submit", function() {
+        $('.form-view-flash-container', _this.el).html('');
+        return $('.form-view-body', _this.el).spin("large");
+      });
+      editor.bind("after:submit", function() {
+        return $('.form-view-body', _this.el).spin(false);
+      });
+      editor.bind("after:submit:fatal_error", function() {
+        $('.form-view-flash-container', _this.el).append("<li class='error'>There was an internal server error saving this record.  Please contact developers@benchprep.com to report this error.</li>");
+        return $('.form-view-body', _this.el).spin(false);
+      });
+      editor.bind("after:submit:error", function(form, model, response) {
+        return _(response.errors).each(function(error) {
+          return $('.form-view-flash-container', _this.el).append("<li class='error'>" + error + "</li>");
+        });
+      });
+      editor.bind("after:submit:success", function(form, model, response) {
+        $('.form-view-flash-container', _this.el).append("<li class='success'>Successfully Saved Record</li>");
+        model.set(response.result);
+        form.loadModel(model);
+        grid.refresh();
+        return _.delay(function() {
+          $('.form-view-flash-container li.success', _this.el).fadeOut(1000);
+          return $('.form-view-flash-container', _this.el).html('');
+        }, 4000);
+      });
+      return filter.eachComponent(function(component) {
+        try {
+          return component.bind("on:change", _this.filter_handler);
+        } catch (e) {
+          return;
+        }
+      });
+    },
+    firstActivation: function() {
+      this.getGrid().trigger("first:activation", this, this.getGrid());
+      return this.getFilter().trigger("first:activation", this, this.getGrid());
+    },
+    reload: function() {
+      var editor, filter, grid, manager;
+      manager = this;
+      grid = this.getGrid();
+      filter = this.getFilter();
+      editor = this.getEditor();
+      filter.clear();
+      return grid.applyFilter();
+    },
+    manageRecord: function(record_id) {
+      var model,
+        _this = this;
+      model = this.getCollection().get(record_id);
+      if (model) return this.loadModel(model);
+      console.log("Could Not Find Model, building and fetching");
+      model = this.buildModel();
+      model.set({
+        id: record_id
+      }, {
+        silent: true
+      });
+      return model.fetch({
+        success: function(model, response) {
+          return _this.loadModel(model);
+        }
+      });
+    },
+    loadModel: function(current_model) {
+      this.current_model = current_model;
+      this.getEditor(true).loadModel(this.current_model);
+      return this.trigger("model:loaded", this.current_model);
+    },
+    currentModel: function() {
+      return this.getEditor(false).currentModel();
+    },
+    buildModel: function() {
+      var collection, editor, model;
+      editor = this.getEditor(false);
+      collection = this.getCollection();
+      collection.add([{}], {
+        silent: true,
+        at: 0
+      });
+      return model = collection.at(0);
+    },
+    createModel: function() {
+      return this.loadModel(this.buildModel());
+    },
+    reset_filter_handler: function(e) {
+      this.getFilter().clear();
+      return this.getGrid().applyFilter(this.getFilter().getValues());
+    },
+    filter_handler: function(e) {
+      return this.getGrid().applyFilter(this.getFilter().getValues());
+    },
+    edit_handler: function(e) {
+      var me, model, my, record_id;
+      me = my = $(e.currentTarget);
+      record_id = my.parents('tr').data('record-id');
+      if (record_id) model = this.getGrid().collection.get(record_id);
+      return model || (model = this.getGrid().collection.at(row_index));
+    },
+    add_handler: function(e) {
+      var me, my, resource;
+      me = my = $(e.currentTarget);
+      return resource = my.parents('.record-manager').eq(0).data('resource');
+    },
+    destroy_handler: function(e) {},
+    back_to_search_handler: function() {}
+  });
+
+}).call(this);

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

@@ -0,0 +1,36 @@
+(function() {
+
+  Luca.Router = Backbone.Router.extend({
+    routes: {
+      "": "default"
+    },
+    initialize: function(options) {
+      var _this = this;
+      this.options = options;
+      _.extend(this, this.options);
+      this.routeHandlers = _(this.routes).values();
+      return _(this.routeHandlers).each(function(route_id) {
+        return _this.bind("route:" + route_id, function() {
+          return _this.trigger.apply(_this, ["change:navigation", route_id].concat(_(arguments).flatten()));
+        });
+      });
+    },
+    navigate: function(route, triggerRoute) {
+      if (triggerRoute == null) triggerRoute = false;
+      Backbone.Router.prototype.navigate.apply(this, arguments);
+      return this.buildPathFrom(Backbone.history.getFragment());
+    },
+    buildPathFrom: function(matchedRoute) {
+      var _this = this;
+      return _(this.routes).each(function(route_id, route) {
+        var args, regex;
+        regex = _this._routeToRegExp(route);
+        if (regex.test(matchedRoute)) {
+          args = _this._extractParameters(regex, matchedRoute);
+          return _this.trigger.apply(_this, ["change:navigation", route_id].concat(args));
+        }
+      });
+    }
+  });
+
+}).call(this);

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

@@ -0,0 +1,26 @@
+(function() {
+
+  Luca.components.Template = Luca.View.extend({
+    initialize: function(options) {
+      this.options = options != null ? options : {};
+      Luca.View.prototype.initialize.apply(this, arguments);
+      if (!(this.template || this.markup)) {
+        throw "Templates must specify which template / markup to use";
+      }
+      if (_.isString(this.templateContainer)) {
+        return this.templateContainer = eval("(window || global)." + this.templateContainer);
+      }
+    },
+    templateContainer: "Luca.templates",
+    beforeRender: function() {
+      if (_.isUndefined(this.templateContainer)) this.templateContainer = JST;
+      return this.$el.html(this.markup || this.templateContainer[this.template](this.options));
+    },
+    render: function() {
+      return $(this.container).append(this.$el);
+    }
+  });
+
+  Luca.register("template", "Luca.components.Template");
+
+}).call(this);

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

@@ -0,0 +1,11 @@
+.luca-ui-toolbar-wrapper {
+  clear: both;
+  display: block;
+  float: left;
+  width: 100%; }
+  .luca-ui-toolbar-wrapper .luca-ui-form-toolbar, .luca-ui-toolbar-wrapper .luca-ui-toolbar {
+    clear: both;
+    margin: 5px auto; }
+    .luca-ui-toolbar-wrapper .luca-ui-form-toolbar .luca-ui-field, .luca-ui-toolbar-wrapper .luca-ui-toolbar .luca-ui-field {
+      float: left;
+      margin: 5px; }

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

@@ -0,0 +1,98 @@
+(function() {
+
+  Luca.containers.CardView = Luca.core.Container.extend({
+    componentType: 'card_view',
+    className: 'luca-ui-card-view-wrapper',
+    activeCard: 0,
+    components: [],
+    hooks: ['before:card:switch', 'after:card:switch'],
+    initialize: function(options) {
+      this.options = options;
+      Luca.core.Container.prototype.initialize.apply(this, arguments);
+      return this.setupHooks(this.hooks);
+    },
+    componentClass: 'luca-ui-card',
+    beforeLayout: function() {
+      var _this = this;
+      return this.cards = _(this.components).map(function(card, cardIndex) {
+        return {
+          classes: _this.componentClass,
+          style: "display:" + (cardIndex === _this.activeCard ? 'block' : 'none'),
+          id: "" + _this.cid + "-" + cardIndex
+        };
+      });
+    },
+    prepareLayout: function() {
+      var _this = this;
+      return this.card_containers = _(this.cards).map(function(card, index) {
+        _this.$el.append(Luca.templates["containers/basic"](card));
+        return $("#" + card.id);
+      });
+    },
+    prepareComponents: function() {
+      var _this = this;
+      return this.components = _(this.components).map(function(object, index) {
+        var card;
+        card = _this.cards[index];
+        object.container = "#" + card.id;
+        return object;
+      });
+    },
+    activeComponent: function() {
+      return this.getComponent(this.activeCard);
+    },
+    cycle: function() {
+      var nextIndex;
+      nextIndex = this.activeCard < this.components.length - 1 ? this.activeCard + 1 : 0;
+      return this.activate(nextIndex);
+    },
+    find: function(name) {
+      return this.findComponentByName(name, true);
+    },
+    firstActivation: function() {
+      return this.activeComponent().trigger("first:activation", this, this.activeComponent());
+    },
+    activate: function(index, silent, callback) {
+      var current, previous, _ref;
+      if (silent == null) silent = false;
+      if (_.isFunction(silent)) {
+        silent = false;
+        callback = silent;
+      }
+      if (index === this.activeCard) return;
+      previous = this.activeComponent();
+      current = this.getComponent(index);
+      if (!current) {
+        index = this.indexOf(index);
+        current = this.getComponent(index);
+      }
+      if (!current) return;
+      if (!silent) this.trigger("before:card:switch", previous, current);
+      _(this.card_containers).each(function(container) {
+        var _ref;
+        if ((_ref = container.trigger) != null) {
+          _ref.apply(container, ["deactivation", this, previous, current]);
+        }
+        return container.hide();
+      });
+      if (!current.previously_activated) {
+        current.trigger("first:activation");
+        current.previously_activated = true;
+      }
+      $(current.container).show();
+      this.activeCard = index;
+      if (!silent) {
+        this.trigger("after:card:switch", previous, current);
+        if ((_ref = current.trigger) != null) {
+          _ref.apply(current, ["activation", this, previous, current]);
+        }
+      }
+      if (_.isFunction(callback)) {
+        return callback.apply(this, [this, previous, current]);
+      }
+    }
+  });
+
+  Luca.register('card_view', "Luca.containers.CardView");
+
+}).call(this);

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

@@ -0,0 +1,52 @@
+(function() {
+
+  Luca.containers.ColumnView = Luca.core.Container.extend({
+    componentType: 'column_view',
+    className: 'luca-ui-column-view',
+    components: [],
+    initialize: function(options) {
+      this.options = options != null ? options : {};
+      Luca.core.Container.prototype.initialize.apply(this, arguments);
+      return this.setColumnWidths();
+    },
+    componentClass: 'luca-ui-column',
+    containerTemplate: "containers/basic",
+    appendContainers: true,
+    autoColumnWidths: function() {
+      var widths,
+        _this = this;
+      widths = [];
+      _(this.components.length).times(function() {
+        return widths.push(parseInt(100 / _this.components.length));
+      });
+      return widths;
+    },
+    setColumnWidths: function() {
+      this.columnWidths = this.layout != null ? _(this.layout.split('/')).map(function(v) {
+        return parseInt(v);
+      }) : this.autoColumnWidths();
+      return this.columnWidths = _(this.columnWidths).map(function(val) {
+        return "" + val + "%";
+      });
+    },
+    beforeComponents: function() {
+      this.debug("column_view before components");
+      return _(this.components).each(function(component) {
+        return component.ctype || (component.ctype = "panel_view");
+      });
+    },
+    beforeLayout: function() {
+      var _ref,
+        _this = this;
+      this.debug("column_view before layout");
+      _(this.columnWidths).each(function(width, index) {
+        _this.components[index].float = "left";
+        return _this.components[index].width = width;
+      });
+      return (_ref = Luca.core.Container.prototype.beforeLayout) != null ? _ref.apply(this, arguments) : void 0;
+    }
+  });
+
+  Luca.register('column_view', "Luca.containers.ColumnView");
+
+}).call(this);

data/vendor/assets/luca-ui/containers/container.css

@@ -0,0 +1,3 @@
+.luca-ui-card {
+  padding: 5px;
+  width: 100%; }

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

@@ -0,0 +1,87 @@
+(function() {
+
+  Luca.containers.ModalView = Luca.core.Container.extend({
+    componentType: 'modal_view',
+    className: 'luca-ui-modal-view',
+    components: [],
+    renderOnInitialize: true,
+    showOnRender: false,
+    hooks: ['before:show', 'before:hide'],
+    defaultModalOptions: {
+      minWidth: 375,
+      maxWidth: 375,
+      minHeight: 550,
+      maxHeight: 550,
+      opacity: 80,
+      onOpen: function(modal) {
+        this.onOpen.apply(this);
+        return this.onModalOpen.apply(modal, [modal, this]);
+      },
+      onClose: function(modal) {
+        this.onClose.apply(this);
+        return this.onModalClose.apply(modal, [modal, this]);
+      }
+    },
+    modalOptions: {},
+    initialize: function(options) {
+      var _this = this;
+      this.options = options != null ? options : {};
+      Luca.core.Container.prototype.initialize.apply(this, arguments);
+      this.setupHooks(this.hooks);
+      _(this.defaultModalOptions).each(function(value, setting) {
+        var _base;
+        return (_base = _this.modalOptions)[setting] || (_base[setting] = value);
+      });
+      this.modalOptions.onOpen = _.bind(this.modalOptions.onOpen, this);
+      return this.modalOptions.onClose = _.bind(this.modalOptions.onClose, this);
+    },
+    onOpen: function() {
+      return true;
+    },
+    onClose: function() {
+      return true;
+    },
+    getModal: function() {
+      return this.modal;
+    },
+    onModalOpen: function(modal, view) {
+      view.modal = modal;
+      modal.overlay.show();
+      modal.container.show();
+      return modal.data.show();
+    },
+    onModalClose: function(modal, view) {
+      return $.modal.close();
+    },
+    prepareLayout: function() {
+      return $('body').append(this.$el);
+    },
+    prepareComponents: function() {
+      var _this = this;
+      return this.components = _(this.components).map(function(object, index) {
+        object.container = _this.el;
+        return object;
+      });
+    },
+    afterInitialize: function() {
+      this.$el.hide();
+      if (this.renderOnInitialize) return this.render();
+    },
+    afterRender: function() {
+      if (this.showOnRender) return this.show();
+    },
+    wrapper: function() {
+      return $(this.$el.parent());
+    },
+    show: function() {
+      this.trigger("before:show", this);
+      return this.$el.modal(this.modalOptions);
+    },
+    hide: function() {
+      return this.trigger("before:hide", this);
+    }
+  });
+
+  Luca.register("modal_view", "Luca.containers.ModalView");
+
+}).call(this);

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

@@ -0,0 +1,34 @@
+(function() {
+
+  Luca.containers.PanelView = Luca.core.Container.extend({
+    className: 'luca-ui-panel',
+    initialize: function(options) {
+      this.options = options != null ? options : {};
+      return Luca.core.Container.prototype.initialize.apply(this, arguments);
+    },
+    afterLayout: function() {
+      var contents;
+      if (this.template) {
+        contents = (Luca.templates || JST)[this.template](this);
+        return this.$el.html(contents);
+      }
+    },
+    render: function() {
+      return $(this.container).append(this.$el);
+    },
+    afterRender: function() {
+      var _ref,
+        _this = this;
+      if ((_ref = Luca.core.Container.prototype.afterRender) != null) {
+        _ref.apply(this, arguments);
+      }
+      if (this.css) {
+        console.log("Yes Yes Yall", this.css, this.$el);
+        return _(this.css).each(function(value, property) {
+          return _this.$el.css(property, value);
+        });
+      }
+    }
+  });
+
+}).call(this);

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

@@ -0,0 +1,13 @@
+(function() {
+
+  Luca.containers.SplitView = Luca.core.Container.extend({
+    layout: '100',
+    componentType: 'split_view',
+    containerTemplate: 'containers/basic',
+    className: 'luca-ui-split-view',
+    componentClass: 'luca-ui-panel'
+  });
+
+  Luca.register('split_view', "Luca.containers.SplitView");
+
+}).call(this);

data/vendor/assets/luca-ui/containers/tab_view.css

@@ -0,0 +1,16 @@
+.luca-ui-tab-view .luca-ui-card .luca-ui-grid-view, .luca-ui-tab-view .luca-ui-card .luca-ui-form-view, .luca-ui-tab-view .luca-ui-card .luca-ui-card {
+  overflow: hidden; }
+
+.luca-ui-tab-view.tabs-below .tab-selector-container, .luca-ui-tab-view.tabs-right .tab-selector-container {
+  display: block;
+  clear: both; }
+
+.luca-ui-tab-view.tabs-left .tab-selector-container {
+  float: left; }
+.luca-ui-tab-view.tabs-left .tab-content {
+  float: left; }
+
+.luca-ui-tab-view.tabs-right .tab-selector-container {
+  float: right; }
+.luca-ui-tab-view.tabs-right .tab-content {
+  float: left; }

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

@@ -0,0 +1,80 @@
+(function() {
+
+  Luca.containers.TabView = Luca.containers.CardView.extend({
+    events: {
+      "click ul.nav-tabs li": "select"
+    },
+    hooks: ["before:select", "after:select"],
+    componentType: 'tab_view',
+    className: 'luca-ui-tab-view tabbable',
+    tab_position: 'top',
+    tabVerticalOffset: '50px',
+    initialize: function(options) {
+      this.options = options != null ? options : {};
+      Luca.containers.CardView.prototype.initialize.apply(this, arguments);
+      _.bindAll(this, "select", "highlightSelectedTab");
+      this.setupHooks(this.hooks);
+      return this.bind("after:card:switch", this.highlightSelectedTab);
+    },
+    activeTabSelector: function() {
+      return this.tabSelectors().eq(this.activeCard);
+    },
+    prepareLayout: function() {
+      var _this = this;
+      return this.card_containers = _(this.cards).map(function(card, index) {
+        _this.$('.tab-content').append(Luca.templates["containers/basic"](card));
+        return $("#" + card.id);
+      });
+    },
+    beforeLayout: function() {
+      this.$el.addClass("tabs-" + this.tab_position);
+      if (this.tab_position === "below") {
+        this.$el.append(Luca.templates["containers/tab_view"](this));
+        this.$el.append(Luca.templates["containers/tab_selector_container"](this));
+      } else {
+        this.$el.append(Luca.templates["containers/tab_selector_container"](this));
+        this.$el.append(Luca.templates["containers/tab_view"](this));
+      }
+      return Luca.containers.CardView.prototype.beforeLayout.apply(this, arguments);
+    },
+    beforeRender: function() {
+      var _ref;
+      if ((_ref = Luca.containers.CardView.prototype.beforeRender) != null) {
+        _ref.apply(this, arguments);
+      }
+      this.activeTabSelector().addClass('active');
+      if (Luca.enableBootstrap && this.tab_position === "left" || this.tab_position === "right") {
+        this.$el.addClass('grid-12');
+        this.tabContainerWrapper().addClass('grid-3');
+        this.tabContentWrapper().addClass('grid-9');
+        if (this.tabVerticalOffset) {
+          return this.tabContainerWrapper().css('padding-top', this.tabVerticalOffset);
+        }
+      }
+    },
+    highlightSelectedTab: function() {
+      this.tabSelectors().removeClass('active');
+      return this.activeTabSelector().addClass('active');
+    },
+    select: function(e) {
+      var me, my;
+      me = my = $(e.currentTarget);
+      this.trigger("before:select", this);
+      this.activate(my.data('target'));
+      return this.trigger("after:select", this);
+    },
+    tabContentWrapper: function() {
+      return $("#" + this.cid + "-tab-view-content");
+    },
+    tabContainerWrapper: function() {
+      return $("#" + this.cid + "-tabs-selector");
+    },
+    tabContainer: function() {
+      return $("ul#" + this.cid + "-tabs-nav");
+    },
+    tabSelectors: function() {
+      return $('li.tab-selector', this.tabContainer());
+    }
+  });
+
+}).call(this);