luca 0.9.4 → 0.9.6

data/src/util.coffee

@@ -3,14 +3,26 @@
 # references on objects which don't yet exist, as strings, which get
 # evaluated at runtime when such references will be available
 Luca.util.resolve = (accessor, source_object)->
-  source_object ||= (window || global)
-  _( accessor.split(/\./) ).inject (obj,key)->
-    obj = obj?[key]
-  , source_object
+  try
+    source_object ||= (window || global)
+    resolved = _( accessor.split(/\./) ).inject (obj,key)->
+      obj = obj?[key]
+    , source_object
+  catch e
+    console.log "Error resolving", accessor, source_object
+    throw e
+    
+  resolved
 
 # A better name for Luca.util.nestedValue
 Luca.util.nestedValue = Luca.util.resolve
 
+Luca.util.argumentsLogger = (prompt)->
+  ()-> console.log prompt, arguments
+
+Luca.util.read = (property, args...)->
+  if _.isFunction(property) then property.apply(@, args) else property
+
 # turns a word like form_view into FormView
 Luca.util.classify = (string="")->
   _.string.camelize( _.string.capitalize( string ) )
@@ -105,3 +117,4 @@ Luca.util.badge = (contents="", type, baseClass="badge")->
   cssClass = baseClass
   cssClass += " #{ baseClass }-#{ type }" if type?
   Luca.util.make("span",{class:cssClass},contents)
+

data/vendor/assets/javascripts/luca-ui-base.js

@@ -18,7 +18,7 @@
   };
 
   _.extend(Luca, {
-    VERSION: "0.9.2",
+    VERSION: "0.9.45",
     core: {},
     containers: {},
     components: {},
@@ -55,8 +55,8 @@
     return memo;
   }, {});
 
-  Luca.find = function() {
-    return;
+  Luca.find = function(el) {
+    return Luca($(el).data('luca-id'));
   };
 
   Luca.supportsEvents = Luca.supportsBackboneEvents = function(obj) {
@@ -228,62 +228,96 @@
 
 }).call(this);
 (function() {
-  var DeferredBindingProxy;
-
-  DeferredBindingProxy = (function() {
-
-    function DeferredBindingProxy(object, operation, wrapWithUnderscore) {
-      var fn,
-        _this = this;
-      this.object = object;
-      if (wrapWithUnderscore == null) wrapWithUnderscore = true;
-      if (_.isFunction(operation)) {
-        fn = operation;
-      } else if (_.isString(operation) && _.isFunction(this.object[operation])) {
-        fn = this.object[operation];
-      }
-      if (!_.isFunction(fn)) {
-        throw "Must pass a function or a string representing one";
-      }
-      if (wrapWithUnderscore === true) {
-        this.fn = function() {
-          return _.defer(fn);
-        };
-      } else {
-        this.fn = fn;
-      }
-      this;
-    }
-
-    DeferredBindingProxy.prototype.until = function(watch, trigger) {
-      if ((watch != null) && !(trigger != null)) {
-        trigger = watch;
-        watch = this.object;
-      }
-      watch.once(trigger, this.fn);
-      return this.object;
-    };
-
-    return DeferredBindingProxy;
-
-  })();
-
-  Luca.Events = {
-    defer: function(operation, wrapWithUnderscore) {
-      if (wrapWithUnderscore == null) wrapWithUnderscore = true;
-      return new DeferredBindingProxy(this, operation, wrapWithUnderscore);
-    },
-    once: function(trigger, callback, context) {
-      var onceFn;
-      context || (context = this);
-      onceFn = function() {
-        callback.apply(context, arguments);
-        return this.unbind(trigger, onceFn);
-      };
-      return this.bind(trigger, onceFn);
-    }
-  };
-
+  this.JST || (this.JST = {});
+  this.JST["luca-src/templates/components/bootstrap_form_controls"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<div class="btn-group form-actions">\n  <a class="btn btn-primary submit-button">\n    <i class="icon icon-ok icon-white"></i>\n    Save Changes\n  </a>\n  <a class="btn reset-button cancel-button">\n    <i class="icon icon-remove"></i>\n    Cancel\n  </a>\n</div>\n');}return __p.join('');};
+}).call(this);
+(function() {
+  this.JST || (this.JST = {});
+  this.JST["luca-src/templates/components/collection_loader_view"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<div id="progress-modal" class="modal" style="display: none">\n  <div class="progress progress-info progress-striped active">\n    <div class="bar" style="width:0%;"></div>\n  </div>\n  <div class="message">Initializing...</div>\n</div>\n');}return __p.join('');};
+}).call(this);
+(function() {
+  this.JST || (this.JST = {});
+  this.JST["luca-src/templates/components/form_alert"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<div class="', className ,'">\n  <a class="close" href="#" data-dismiss="alert">x</a>\n  ', message ,'\n</div>\n');}return __p.join('');};
+}).call(this);
+(function() {
+  this.JST || (this.JST = {});
+  this.JST["luca-src/templates/components/grid_view"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<div class="luca-ui-g-view-wrapper">\n  <div class="g-view-header"></div>\n  <div class="luca-ui-g-view-body">\n    <table class="luca-ui-g-view scrollable-table" width="100%" cellpadding=0 cellspacing=0>\n      <thead class="fixed"></thead>\n      <tbody class="scrollable"></tbody>\n      <tfoot></tfoot>\n    </table>\n  </div>\n  <div class="luca-ui-g-view-header"></div>\n</div>\n');}return __p.join('');};
+}).call(this);
+(function() {
+  this.JST || (this.JST = {});
+  this.JST["luca-src/templates/components/grid_view_empty_text"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<div class="empty-text empty-text-wrapper">\n  <p>', text ,'</p>\n</div>\n');}return __p.join('');};
+}).call(this);
+(function() {
+  this.JST || (this.JST = {});
+  this.JST["luca-src/templates/components/load_mask"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<div class="load-mask">\n  <div class="progress progress-striped active">\n    <div class="bar" style="width:0%"></div>\n  </div>\n</div>\n');}return __p.join('');};
+}).call(this);
+(function() {
+  this.JST || (this.JST = {});
+  this.JST["luca-src/templates/components/nav_bar"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<div class="navbar-inner">\n  <div class="luca-ui-navbar-body container">\n  </div>\n</div>\n');}return __p.join('');};
+}).call(this);
+(function() {
+  this.JST || (this.JST = {});
+  this.JST["luca-src/templates/components/pagination"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<div class="pagination">\n  <a class="btn previous">\n    <i class="icon icon-chevron-left"></i>\n  </a>\n  <div class="pagination-group">\n  </div>\n  <a class="btn next">\n    <i class="icon icon-chevron-right"></i>\n  </a>\n</div>\n');}return __p.join('');};
+}).call(this);
+(function() {
+  this.JST || (this.JST = {});
+  this.JST["luca-src/templates/containers/basic"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<div id="', id ,'" class="', classes ,'" style="', style ,'"></div>\n');}return __p.join('');};
+}).call(this);
+(function() {
+  this.JST || (this.JST = {});
+  this.JST["luca-src/templates/containers/tab_selector_container"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<div id="', cid ,'-tab-selector" class="tab-selector-container">\n  <ul id="', cid ,'-tabs-nav" class="nav nav-tabs">\n    '); for(var i = 0; i < components.length; i++ ) { __p.push('\n    '); var component = components[i];__p.push('\n    <li class="tab-selector" data-target="', i ,'">\n      <a data-target="', i ,'">\n        ', component.title ,'\n      </a>\n    </li>\n    '); } __p.push('\n  </ul>\n</div>\n');}return __p.join('');};
+}).call(this);
+(function() {
+  this.JST || (this.JST = {});
+  this.JST["luca-src/templates/containers/tab_view"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<ul id="', cid ,'-tabs-selector" class="nav ', navClass ,'"></ul>\n<div id="', cid ,'-tab-view-content" class="tab-content"></div>\n');}return __p.join('');};
+}).call(this);
+(function() {
+  this.JST || (this.JST = {});
+  this.JST["luca-src/templates/containers/toolbar_wrapper"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<div class="luca-ui-toolbar-wrapper" id="', id ,'"></div>\n');}return __p.join('');};
+}).call(this);
+(function() {
+  this.JST || (this.JST = {});
+  this.JST["luca-src/templates/fields/button_field"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<label>&nbsp;</label>\n<input style="', inputStyles ,'" class="btn ', input_class ,'" value="', input_value ,'" type="', input_type ,'" id="<%= input_id" />\n');}return __p.join('');};
+}).call(this);
+(function() {
+  this.JST || (this.JST = {});
+  this.JST["luca-src/templates/fields/button_field_link"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<a class="btn ', input_class ,'">\n  '); if(icon_class.length) { __p.push('\n  <i class="', icon_class ,'"></i>\n  ', input_value ,'\n  '); } __p.push('\n</a>\n');}return __p.join('');};
+}).call(this);
+(function() {
+  this.JST || (this.JST = {});
+  this.JST["luca-src/templates/fields/checkbox_array"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<div class="control-group">\n  <label for="', input_id ,'"><%= label =>\n  <div class="controls"><div>\n</div>\n');}return __p.join('');};
+}).call(this);
+(function() {
+  this.JST || (this.JST = {});
+  this.JST["luca-src/templates/fields/checkbox_array_item"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<label for="', input_id ,'">\n  <input id="', input_id ,'" type="checkbox" name="', input_name ,'" value="', value ,'" />\n</label>\n');}return __p.join('');};
+}).call(this);
+(function() {
+  this.JST || (this.JST = {});
+  this.JST["luca-src/templates/fields/checkbox_field"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<label for="', input_id ,'">\n  ', label ,'\n  <input type="checkbox" name="', input_name ,'" value="', input_value ,'" style="', inputStyles ,'" />\n</label>\n\n'); if(helperText) { __p.push('\n<p class="helper-text help-block">\n  ', helperText ,'\n</p>\n'); } __p.push('\n');}return __p.join('');};
+}).call(this);
+(function() {
+  this.JST || (this.JST = {});
+  this.JST["luca-src/templates/fields/file_upload_field"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<label for="', input_id ,'">\n  ', label ,'\n  <input type="file" name="', input_name ,'" value="', input_value ,'" style="', inputStyles ,'" />\n</label>\n\n'); if(helperText) { __p.push('\n<p class="helper-text help-block">\n  ', helperText ,'\n</p>\n'); } __p.push('\n');}return __p.join('');};
+}).call(this);
+(function() {
+  this.JST || (this.JST = {});
+  this.JST["luca-src/templates/fields/hidden_field"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push(' <input type="hidden" name="', input_name ,'" value="', input_value ,'" style="', inputStyles ,'" />\n');}return __p.join('');};
+}).call(this);
+(function() {
+  this.JST || (this.JST = {});
+  this.JST["luca-src/templates/fields/select_field"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<label for="', input_id ,'">\n  ', label ,'\n</label>\n<div class="controls">\n <select name="', input_name ,'" value="', input_value ,'" style="', inputStyles ,'" ></select>\n  '); if(helperText) { __p.push('\n  <p class="helper-text help-block">\n    ', helperText ,'\n  </p>\n  '); } __p.push('\n</div>\n');}return __p.join('');};
+}).call(this);
+(function() {
+  this.JST || (this.JST = {});
+  this.JST["luca-src/templates/fields/text_area_field"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<label for="', input_id ,'">\n  ', label ,'\n</label>\n<div class="controls">\n <textarea name="', input_name ,'" style="', inputStyles ,'" >', input_value ,'</textarea>\n  '); if(helperText) { __p.push('\n  <p class="helper-text help-block">\n    ', helperText ,'\n  </p>\n  '); } __p.push('\n</div>\n');}return __p.join('');};
+}).call(this);
+(function() {
+  this.JST || (this.JST = {});
+  this.JST["luca-src/templates/fields/text_field"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push(''); if(typeof(label)!=="undefined" && (typeof(hideLabel) !== "undefined" && !hideLabel) || (typeof(hideLabel)==="undefined")) {__p.push('\n<label class="control-label" for="', input_id ,'">', label ,'</label>\n'); } __p.push('\n\n<div class="controls">\n'); if( typeof(addOn) !== "undefined" ) { __p.push('\n  <span class="add-on">', addOn ,'</span>\n'); } __p.push('\n<input type="text" name="', input_name ,'" style="', inputStyles ,'" value="', input_value ,'" />\n'); if(helperText) { __p.push('\n<p class="helper-text help-block">\n  ', helperText ,'\n</p>\n'); } __p.push('\n\n</div>\n');}return __p.join('');};
+}).call(this);
+(function() {
+  this.JST || (this.JST = {});
+  this.JST["luca-src/templates/table_view"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<thead></thead>\n<tbody class="table-body"></tbody>\n<tfoot></tfoot>\n<caption></caption>\n');}return __p.join('');};
 }).call(this);
 (function() {
   var currentNamespace;
@@ -297,6 +331,12 @@
 
   Luca.util.nestedValue = Luca.util.resolve;
 
+  Luca.util.argumentsLogger = function(prompt) {
+    return function() {
+      return console.log(prompt, arguments);
+    };
+  };
+
   Luca.util.classify = function(string) {
     if (string == null) string = "";
     return _.string.camelize(_.string.capitalize(string));
@@ -371,6 +411,20 @@
 
   Luca.util.make = Backbone.View.prototype.make;
 
+  Luca.util.list = function(list, options, ordered) {
+    var container, item, _i, _len;
+    if (options == null) options = {};
+    container = ordered ? "ol" : "ul";
+    container = Luca.util.make(container, options);
+    if (_.isArray(list)) {
+      for (_i = 0, _len = list.length; _i < _len; _i++) {
+        item = list[_i];
+        $(container).append(Luca.util.make("li", {}, item));
+      }
+    }
+    return container.outerHTML;
+  };
+
   Luca.util.label = function(contents, type, baseClass) {
     var cssClass;
     if (contents == null) contents = "";
@@ -395,7 +449,164 @@
 
 }).call(this);
 (function() {
-  var DefineProxy;
+
+  Luca.DevelopmentToolHelpers = {
+    refreshCode: function() {
+      var view;
+      view = this;
+      _(this.eventHandlerProperties()).each(function(prop) {
+        return view[prop] = view.definitionClass()[prop];
+      });
+      if (this.autoBindEventHandlers === true) this.bindAllEventHandlers();
+      return this.delegateEvents();
+    },
+    eventHandlerProperties: function() {
+      var handlerIds;
+      handlerIds = _(this.events).values();
+      return _(handlerIds).select(function(v) {
+        return _.isString(v);
+      });
+    },
+    eventHandlerFunctions: function() {
+      var handlerIds,
+        _this = this;
+      handlerIds = _(this.events).values();
+      return _(handlerIds).map(function(handlerId) {
+        if (_.isFunction(handlerId)) {
+          return handlerId;
+        } else {
+          return _this[handlerId];
+        }
+      });
+    }
+  };
+
+}).call(this);
+(function() {
+  var DeferredBindingProxy,
+    __slice = Array.prototype.slice;
+
+  DeferredBindingProxy = (function() {
+
+    function DeferredBindingProxy(object, operation, wrapWithUnderscore) {
+      var fn;
+      this.object = object;
+      if (wrapWithUnderscore == null) wrapWithUnderscore = true;
+      if (_.isFunction(operation)) {
+        fn = operation;
+      } else if (_.isString(operation) && _.isFunction(this.object[operation])) {
+        fn = this.object[operation];
+      }
+      if (!_.isFunction(fn)) {
+        throw "Must pass a function or a string representing one";
+      }
+      if (wrapWithUnderscore === true) {
+        this.fn = _.bind(function() {
+          return _.defer(fn);
+        }, this.object);
+      } else {
+        this.fn = _.bind(fn, this.object);
+      }
+      this;
+    }
+
+    DeferredBindingProxy.prototype.until = function(watch, trigger) {
+      if ((watch != null) && !(trigger != null)) {
+        trigger = watch;
+        watch = this.object;
+      }
+      watch.once(trigger, this.fn);
+      return this.object;
+    };
+
+    return DeferredBindingProxy;
+
+  })();
+
+  Luca.Events = {
+    defer: function(operation, wrapWithUnderscore) {
+      if (wrapWithUnderscore == null) wrapWithUnderscore = true;
+      return new DeferredBindingProxy(this, operation, wrapWithUnderscore);
+    },
+    once: function(trigger, callback, context) {
+      var onceFn;
+      context || (context = this);
+      onceFn = function() {
+        callback.apply(context, arguments);
+        return this.unbind(trigger, onceFn);
+      };
+      return this.bind(trigger, onceFn);
+    }
+  };
+
+  Luca.EventsExt = {
+    waitUntil: function(trigger, context) {
+      return this.waitFor.call(this, trigger, context);
+    },
+    waitFor: function(trigger, context) {
+      var proxy, self;
+      self = this;
+      return proxy = {
+        on: function(target) {
+          return target.waitFor.call(target, trigger, context);
+        },
+        and: function() {
+          var fn, runList, _i, _len, _results;
+          runList = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+          _results = [];
+          for (_i = 0, _len = runList.length; _i < _len; _i++) {
+            fn = runList[_i];
+            fn = _.isFunction(fn) ? fn : self[fn];
+            _results.push(self.once(trigger, fn, context));
+          }
+          return _results;
+        },
+        andThen: function() {
+          return self.and.apply(self, arguments);
+        }
+      };
+    },
+    relayEvent: function(trigger) {
+      var _this = this;
+      return {
+        on: function() {
+          var components;
+          components = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+          return {
+            to: function() {
+              var component, target, targets, _i, _len, _results;
+              targets = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+              _results = [];
+              for (_i = 0, _len = targets.length; _i < _len; _i++) {
+                target = targets[_i];
+                _results.push((function() {
+                  var _j, _len2, _results2,
+                    _this = this;
+                  _results2 = [];
+                  for (_j = 0, _len2 = components.length; _j < _len2; _j++) {
+                    component = components[_j];
+                    _results2.push(component.on(trigger, function() {
+                      var args;
+                      args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+                      args.unshift(trigger);
+                      return target.trigger.apply(target, args);
+                    }));
+                  }
+                  return _results2;
+                }).call(_this));
+              }
+              return _results;
+            }
+          };
+        }
+      };
+    }
+  };
+
+}).call(this);
+(function() {
+  var DefineProxy,
+    __slice = Array.prototype.slice;
 
   Luca.define = function(componentName) {
     return new DefineProxy(componentName);
@@ -443,14 +654,44 @@
       return this;
     };
 
+    DefineProxy.prototype.defaultsTo = function(properties) {
+      if (properties != null) return this["with"](properties);
+      return this;
+    };
+
+    DefineProxy.prototype.defaults = function(properties) {
+      if (properties != null) return this["with"](properties);
+      return this;
+    };
+
+    DefineProxy.prototype.hasDefaultProperties = function(properties) {
+      if (properties != null) return this["with"](properties);
+      return this;
+    };
+
+    DefineProxy.prototype.behavesAs = function() {
+      var mixin, mixins, _i, _len;
+      mixins = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+      _.defaults(this.properties || (this.properties = {}), {
+        mixins: []
+      });
+      for (_i = 0, _len = mixins.length; _i < _len; _i++) {
+        mixin = mixins[_i];
+        this.properties.mixins.push(mixin);
+      }
+      return this;
+    };
+
     DefineProxy.prototype["with"] = function(properties) {
       var at, componentType, _base;
+      if (properties == null) properties = {};
+      _.defaults((this.properties || (this.properties = {})), properties);
       at = this.namespaced ? Luca.util.resolve(this.namespace, window || global) : window || global;
       if (this.namespaced && !(at != null)) {
         eval("(window||global)." + this.namespace + " = {}");
         at = Luca.util.resolve(this.namespace, window || global);
       }
-      at[this.componentId] = Luca.extend(this.superClassName, this.componentName, properties);
+      at[this.componentId] = Luca.extend(this.superClassName, this.componentName, this.properties);
       if (Luca.autoRegister === true) {
         if (Luca.isViewPrototype(at[this.componentId])) componentType = "view";
         if (Luca.isCollectionPrototype(at[this.componentId])) {
@@ -469,7 +710,7 @@
   })();
 
   Luca.extend = function(superClassName, childName, properties) {
-    var superClass;
+    var definition, include, superClass, _i, _len, _ref;
     if (properties == null) properties = {};
     superClass = Luca.util.resolve(superClassName, window || global);
     if (!_.isFunction(superClass != null ? superClass.extend : void 0)) {
@@ -484,39 +725,453 @@
       var _ref;
       return (_ref = this._superClass().prototype[method]) != null ? _ref.apply(context, args) : void 0;
     };
-    return superClass.extend(properties);
+    definition = superClass.extend(properties);
+    if (_.isArray(properties != null ? properties.include : void 0)) {
+      _ref = properties.include;
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        include = _ref[_i];
+        if (_.isString(include)) include = Luca.util.resolve(include);
+        _.extend(definition.prototype, include);
+      }
+    }
+    return definition;
   };
 
-  _.mixin({
-    def: Luca.define
-  });
+  Luca.mixin = function(mixinName) {
+    var namespace, resolved;
+    namespace = _(Luca.mixin.namespaces).detect(function(space) {
+      var _ref;
+      return ((_ref = Luca.util.resolve(space)) != null ? _ref[mixinName] : void 0) != null;
+    });
+    namespace || (namespace = "Luca.modules");
+    resolved = Luca.util.resolve(namespace)[mixinName];
+    if (resolved == null) {
+      console.log("Could not find " + mixinName + " in ", Luca.mixin.namespaces);
+    }
+    return resolved;
+  };
 
-}).call(this);
-(function() {
-  var component_cache, registry;
+  Luca.mixin.namespaces = ["Luca.modules"];
 
-  registry = {
-    classes: {},
-    model_classes: {},
-    collection_classes: {},
-    namespaces: ['Luca.containers', 'Luca.components']
+  Luca.mixin.namespace = function(namespace) {
+    Luca.mixin.namespaces.push(namespace);
+    return Luca.mixin.namespaces = _(Luca.mixin.namespaces).uniq();
   };
 
-  component_cache = {
-    cid_index: {},
-    name_index: {}
+  Luca.decorate = function(componentPrototype) {
+    if (_.isString(componentPrototype)) {
+      componentPrototype = Luca.util.resolve(componentPrototype).prototype;
+    }
+    return {
+      "with": function(mixin) {
+        _.extend(componentPrototype, Luca.mixin(mixin));
+        componentPrototype.mixins || (componentPrototype.mixins = []);
+        componentPrototype.mixins.push(mixin);
+        componentPrototype.mixins = _(componentPrototype.mixins).uniq();
+        return componentPrototype;
+      }
+    };
   };
 
-  Luca.defaultComponentType = 'view';
+  _.mixin({
+    def: Luca.define
+  });
 
-  Luca.register = function(component, prototypeName, componentType) {
-    if (componentType == null) componentType = "view";
-    Luca.trigger("component:registered", component, prototypeName);
-    switch (componentType) {
+}).call(this);
+(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);
+(function() {
+  var FilterModel,
+    __hasProp = Object.prototype.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; };
+
+  Luca.modules.Filterable = {
+    _initializer: function(component, module) {
+      var oldOptions, oldQuery, sortBy, _ref, _ref2;
+      if (this.filterable === false) return;
+      this.filterState = this.getFilterModel();
+      if (oldQuery = this.getQuery) {
+        this.getQuery = function() {
+          return _.extend(oldQuery.call(this), this.filterState.toQuery());
+        };
+      }
+      if (oldOptions = this.getQueryOptions) {
+        this.getQueryOptions = function() {
+          return {};
+          return _.extend(oldOptions.call(this), this.filterState.toOptions());
+        };
+      }
+      if (sortBy = (_ref = this.filterable) != null ? (_ref2 = _ref.options) != null ? _ref2.sortBy : void 0 : void 0) {
+        return this.setSortBy(sortBy);
+      }
+    },
+    setSortBy: function(sortBy, options) {
+      if (options == null) options = {};
+      return this.filterState.setOption('sortBy', sortBy, options);
+    },
+    getFilterModel: function() {
+      if (this.filterState != null) return this.filterState;
+      this.filterState = new FilterModel(this.filterable || (this.filterable = {}));
+      this.filterState.on("change", function() {
+        return this.trigger("collection:change");
+      }, this);
+      return this.filterState;
+    },
+    applyFilter: function(query, options) {
+      var silent;
+      if (query == null) query = {};
+      if (options == null) options = {};
+      if (_.isEmpty(options)) {
+        options = _.defaults(options, this.getQueryOptions());
+      }
+      if (_.isEmpty(query)) query = _.defaults(query, this.getQuery());
+      silent = _(options)["delete"]('silent') === true;
+      return this.filterState.set({
+        query: query,
+        options: options
+      }, {
+        silent: silent
+      });
+    }
+  };
+
+  FilterModel = (function(_super) {
+
+    __extends(FilterModel, _super);
+
+    function FilterModel() {
+      FilterModel.__super__.constructor.apply(this, arguments);
+    }
+
+    FilterModel.prototype.setOption = function(option, value, options) {
+      var payload;
+      payload = {};
+      payload[option] = value;
+      return this.set('options', _.extend(this.toOptions(), payload), options);
+    };
+
+    FilterModel.prototype.setQueryOption = function(option, value, options) {
+      var payload;
+      payload = {};
+      payload[option] = value;
+      return this.set('query', _.extend(this.toQuery(), payload), options);
+    };
+
+    FilterModel.prototype.toOptions = function() {
+      return this.get("options");
+    };
+
+    FilterModel.prototype.toQuery = function() {
+      return this.get("query");
+    };
+
+    return FilterModel;
+
+  })(Backbone.Model);
+
+}).call(this);
+(function() {
+
+  Luca.modules.GridLayout = {
+    _initializer: function() {
+      if (this.gridSpan) this.$el.addClass("span" + this.gridSpan);
+      if (this.gridOffset) this.$el.addClass("offset" + this.gridOffset);
+      if (this.gridRowFluid) this.$el.addClass("row-fluid");
+      if (this.gridRow) return this.$el.addClass("row");
+    }
+  };
+
+}).call(this);
+(function() {
+
+  Luca.modules.LoadMaskable = {
+    _initializer: function() {
+      var _this = this;
+      if (this.loadMask !== true) return;
+      if (this.loadMask === true) {
+        this.defer(function() {
+          _this.$el.addClass('with-mask');
+          if (_this.$('.load-mask').length === 0) {
+            _this.loadMaskTarget().prepend(Luca.template(_this.loadMaskTemplate, _this));
+            return _this.$('.load-mask').hide();
+          }
+        }).until("after:render");
+        this.on(this.loadmaskEnableEvent || "enable:loadmask", this.applyLoadMask, this);
+        return this.on(this.loadmaskDisableEvent || "disable:loadmask", this.applyLoadMask, this);
+      }
+    },
+    showLoadMask: function() {
+      return this.trigger("enable:loadmask");
+    },
+    hideLoadMask: function() {
+      return this.trigger("disable:loadmask");
+    },
+    loadMaskTarget: function() {
+      if (this.loadMaskEl != null) {
+        return this.$(this.loadMaskEl);
+      } else {
+        return this.$bodyEl();
+      }
+    },
+    disableLoadMask: function() {
+      this.$('.load-mask .bar').css("width", "100%");
+      this.$('.load-mask').hide();
+      return clearInterval(this.loadMaskInterval);
+    },
+    enableLoadMask: function() {
+      var maxWidth,
+        _this = this;
+      this.$('.load-mask').show().find('.bar').css("width", "0%");
+      maxWidth = this.$('.load-mask .progress').width();
+      if (maxWidth < 20 && (maxWidth = this.$el.width()) < 20) {
+        maxWidth = this.$el.parent().width();
+      }
+      this.loadMaskInterval = setInterval(function() {
+        var currentWidth, newWidth;
+        currentWidth = _this.$('.load-mask .bar').width();
+        newWidth = currentWidth + 12;
+        return _this.$('.load-mask .bar').css('width', newWidth);
+      }, 200);
+      if (this.loadMaskTimeout == null) return;
+      return _.delay(function() {
+        return _this.disableLoadMask();
+      }, this.loadMaskTimeout);
+    },
+    applyLoadMask: function() {
+      if (this.$('.load-mask').is(":visible")) {
+        return this.disableLoadMask();
+      } else {
+        return this.enableLoadMask();
+      }
+    }
+  };
+
+}).call(this);
+(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);
+(function() {
+
+  Luca.modules.Paginatable = {
+    paginatorViewClass: 'Luca.components.PaginationControl',
+    _initializer: function() {
+      var old;
+      if (this.paginatable === false) return;
+      _.bindAll(this, "paginationControl");
+      this.getCollection || (this.getCollection = function() {
+        return this.collection;
+      });
+      if (old = this.getQueryOptions) {
+        this.getQueryOptions = function() {
+          var filtered, p;
+          p = this.paginationControl();
+          filtered = _.extend(old.call(this), {
+            limit: p.limit(),
+            page: p.page()
+          });
+          return filtered;
+        };
+      }
+      if (this.paginationContainer().length === 0) {
+        return this.$bodyEl().after(this.make("div", {
+          "class": "toolbar bottom"
+        }));
+      }
+    },
+    paginationContainer: function() {
+      return this.$('.toolbar.bottom');
+    },
+    setCurrentPage: function(page, options) {
+      if (page == null) page = 1;
+      if (options == null) options = {};
+      return this.paginationControl().state.set('page', page, options);
+    },
+    setLimit: function(limit, options) {
+      if (limit == null) limit = 0;
+      if (options == null) options = {};
+      return this.paginationControl().state.set('limit', limit, options);
+    },
+    updatePagination: function(models, query, options) {
+      var itemCount, paginator, totalCount, _ref;
+      if (models == null) models = [];
+      if (query == null) query = {};
+      if (options == null) options = {};
+      _.defaults(options, this.getQueryOptions(), {
+        limit: 0
+      });
+      paginator = this.paginationControl();
+      itemCount = (models != null ? models.length : void 0) || 0;
+      totalCount = (_ref = this.getCollection()) != null ? _ref.length : void 0;
+      if (itemCount === 0 || totalCount <= options.limit) {
+        paginator.$el.hide();
+      } else {
+        paginator.$el.show();
+      }
+      return paginator.state.set({
+        page: options.page,
+        limit: options.limit
+      });
+    },
+    paginationControl: function() {
+      if (this.paginator != null) return this.paginator;
+      _.defaults(this.paginatable || (this.paginatable = {}), {
+        page: 1,
+        limit: 20
+      });
+      this.paginator = Luca.util.lazyComponent({
+        type: "pagination_control",
+        collection: this.getCollection(),
+        parent: this
+      });
+      this.paginator.setPage(this.paginatable.page);
+      this.paginator.setLimit(this.paginatable.limit);
+      this.paginator.state.on("change", function() {
+        return this.trigger("collection:change");
+      }, this);
+      this.on("after:refresh", this.updatePagination, this);
+      this.paginationContainer().append(this.paginator.render().$el);
+      return this.paginator;
+    }
+  };
+
+}).call(this);
+(function() {
+  var component_cache, registry;
+
+  registry = {
+    classes: {},
+    model_classes: {},
+    collection_classes: {},
+    namespaces: ['Luca.containers', 'Luca.components']
+  };
+
+  component_cache = {
+    cid_index: {},
+    name_index: {}
+  };
+
+  Luca.defaultComponentType = 'view';
+
+  Luca.registry.aliases = {
+    grid: "grid_view",
+    form: "form_view",
+    text: "text_field",
+    button: "button_field",
+    select: "select_field",
+    card: "card_view",
+    paged: "card_view",
+    wizard: "card_view",
+    collection: "collection_view",
+    list: "collection_view",
+    multi: "collection_multi_view",
+    table: "table_view"
+  };
+
+  Luca.register = function(component, prototypeName, componentType) {
+    if (componentType == null) componentType = "view";
+    Luca.trigger("component:registered", component, prototypeName);
+    switch (componentType) {
       case "model":
         return registry.model_classes[component] = prototypeName;
       case "collection":
-        return registry.model_classes[component] = prototypeName;
+        return registry.collection_classes[component] = prototypeName;
       default:
         return registry.classes[component] = prototypeName;
     }
@@ -536,7 +1191,7 @@
     return Luca.register(component, prototypeName);
   };
 
-  Luca.registry.addNamespace = function(identifier) {
+  Luca.registry.addNamespace = Luca.registry.namespace = function(identifier) {
     registry.namespaces.push(identifier);
     return registry.namespaces = _(registry.namespaces).uniq();
   };
@@ -553,7 +1208,8 @@
   };
 
   Luca.registry.lookup = function(ctype) {
-    var c, className, fullPath, parents, _ref;
+    var alias, c, className, fullPath, parents, _ref;
+    if (alias = Luca.registry.aliases[ctype]) ctype = alias;
     c = registry.classes[ctype];
     if (c != null) return c;
     className = Luca.util.classify(ctype);
@@ -563,9 +1219,13 @@
     }).compact().value()) != null ? _ref[0] : void 0;
   };
 
+  Luca.registry.instances = function() {
+    return _(component_cache.cid_index).values();
+  };
+
   Luca.registry.findInstancesByClassName = function(className) {
     var instances;
-    instances = _(component_cache.cid_index).values();
+    instances = Luca.registry.instances();
     return _(instances).select(function(instance) {
       var _ref;
       return instance.displayName === className || (typeof instance._superClass === "function" ? (_ref = instance._superClass()) != null ? _ref.displayName : void 0 : void 0) === className;
@@ -591,10 +1251,8 @@
     if (component != null) component_cache.cid_index[needle] = component;
     component = component_cache.cid_index[needle];
     if ((component != null ? component.component_name : void 0) != null) {
-      Luca.trigger("component:created:" + component.component_name, component);
       component_cache.name_index[component.component_name] = component.cid;
     } else if ((component != null ? component.name : void 0) != null) {
-      Luca.trigger("component:created:" + component.component_name, component);
       component_cache.name_index[component.name] = component.cid;
     }
     if (component != null) return component;
@@ -604,60 +1262,84 @@
 
 }).call(this);
 (function() {
-  var customizeRender, originalExtend;
+  var __slice = Array.prototype.slice;
 
-  _.def("Luca.View")["extends"]("Backbone.View")["with"]({
-    include: ['Luca.Events'],
-    additionalClassNames: [],
-    hooks: ["after:initialize", "before:render", "after:render", "first:activation", "activation", "deactivation"],
-    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) {
-        if (Luca.developmentMode === true || this.observeEvents === true) {
-          Luca.ViewObserver || (Luca.ViewObserver = new Luca.Observer({
-            type: "view"
-          }));
-          Luca.ViewObserver.relay(this, arguments);
-        }
+  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("all", function(trigger, one, two) {
+          return console.log("ALL", trigger, one, two);
+        });
       }
-      return Backbone.View.prototype.trigger.apply(this, arguments);
-    },
+    }
+
+    Observer.prototype.relay = function() {
+      var args, triggerer;
+      triggerer = arguments[0], args = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+      console.log("Relaying", trigger, args);
+      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);
+(function() {
+  var bindAllEventHandlers, registerApplicationEvents, registerCollectionEvents, setupBodyTemplate, setupClassHelpers, setupStateMachine, setupTemplate;
+
+  _.def("Luca.View")["extends"]("Backbone.View")["with"]({
+    include: ['Luca.Events'],
+    additionalClassNames: [],
+    hooks: ["before:initialize", "after:initialize", "before:render", "after:render", "first:activation", "activation", "deactivation"],
     initialize: function(options) {
-      var additional, template, unique, _i, _len, _ref;
+      var module, _i, _len, _ref, _ref2, _ref3;
       this.options = options != null ? options : {};
+      this.trigger("before:initialize", this, this.options);
       _.extend(this, this.options);
-      if (this.name != null) this.cid = _.uniqueId(this.name);
-      if (template = this.bodyTemplate) {
-        this.$el.empty();
-        Luca.View.prototype.$html.call(this, Luca.template(template, this));
+      if (this.autoBindEventHandlers === true || this.bindAllEvents === true) {
+        bindAllEventHandlers.call(this);
       }
+      setupBodyTemplate.call(this);
+      if (this.name != null) this.cid = _.uniqueId(this.name);
+      this.$el.attr("data-luca-id", this.name || this.cid);
       Luca.cache(this.cid, this);
-      unique = _(Luca.View.prototype.hooks.concat(this.hooks)).uniq();
-      this.setupHooks(unique);
-      if (this.autoBindEventHandlers === true) this.bindAllEventHandlers();
-      if (this.additionalClassNames) {
-        if (_.isString(this.additionalClassNames)) {
-          this.additionalClassNames = this.additionalClassNames.split(" ");
-        }
-        _ref = this.additionalClassNames;
-        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
-          additional = _ref[_i];
-          this.$el.addClass(additional);
+      this.setupHooks(_(Luca.View.prototype.hooks.concat(this.hooks)).uniq());
+      setupClassHelpers.call(this);
+      if (this.stateful === true && !(this.state != null)) {
+        setupStateMachine.call(this);
+      }
+      registerCollectionEvents.call(this);
+      registerApplicationEvents.call(this);
+      if (((_ref = this.mixins) != null ? _ref.length : void 0) > 0) {
+        _ref2 = _.uniq(this.mixins);
+        for (_i = 0, _len = _ref2.length; _i < _len; _i++) {
+          module = _ref2[_i];
+          if ((_ref3 = Luca.mixin(module)) != null) {
+            _ref3._initializer.call(this, this, module);
+          }
         }
       }
-      if (this.wrapperClass != null) this.$wrap(this.wrapperClass);
-      this.trigger("after:initialize", this);
-      this.registerCollectionEvents();
-      return this.delegateEvents();
+      this.delegateEvents();
+      if (this.template && !this.isField) setupTemplate.call(this);
+      return this.trigger("after:initialize", this);
     },
     $wrap: function(wrapper) {
       if (_.isString(wrapper) && !wrapper.match(/[<>]/)) {
@@ -680,6 +1362,9 @@
     $attach: function() {
       return this.$container().append(this.el);
     },
+    $bodyEl: function() {
+      return this.$el;
+    },
     $container: function() {
       return $(this.container);
     },
@@ -699,72 +1384,15 @@
         return _this.bind(eventId, callback);
       });
     },
-    getCollectionManager: function() {
-      var _base;
-      return this.collectionManager || (typeof (_base = Luca.CollectionManager).get === "function" ? _base.get() : 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;
-        }
-      });
-    },
     registerEvent: function(selector, handler) {
       this.events || (this.events = {});
       this.events[selector] = handler;
       return this.delegateEvents();
     },
-    bindAllEventHandlers: function() {
-      var _this = this;
-      return _(this.events).each(function(handler, event) {
-        if (_.isString(handler)) return _.bindAll(_this, handler);
-      });
-    },
     definitionClass: function() {
       var _ref;
       return (_ref = Luca.util.resolve(this.displayName, window)) != null ? _ref.prototype : void 0;
     },
-    refreshCode: function() {
-      var view;
-      view = this;
-      _(this.eventHandlerProperties()).each(function(prop) {
-        return view[prop] = view.definitionClass()[prop];
-      });
-      if (this.autoBindEventHandlers === true) this.bindAllEventHandlers();
-      return this.delegateEvents();
-    },
-    eventHandlerProperties: function() {
-      var handlerIds;
-      handlerIds = _(this.events).values();
-      return _(handlerIds).select(function(v) {
-        return _.isString(v);
-      });
-    },
-    eventHandlerFunctions: function() {
-      var handlerIds,
-        _this = this;
-      handlerIds = _(this.events).values();
-      return _(handlerIds).map(function(handlerId) {
-        if (_.isFunction(handlerId)) {
-          return handlerId;
-        } else {
-          return _this[handlerId];
-        }
-      });
-    },
     collections: function() {
       return Luca.util.selectProperties(Luca.isBackboneCollection, this);
     },
@@ -773,12 +1401,33 @@
     },
     views: function() {
       return Luca.util.selectProperties(Luca.isBackboneView, this);
+    },
+    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) {
+        if (Luca.developmentMode === true || this.observeEvents === true) {
+          Luca.ViewObserver || (Luca.ViewObserver = new Luca.Observer({
+            type: "view"
+          }));
+          Luca.ViewObserver.relay(this, arguments);
+        }
+      }
+      return Backbone.View.prototype.trigger.apply(this, arguments);
     }
   });
 
-  originalExtend = Backbone.View.extend;
+  Luca.View._originalExtend = Backbone.View.extend;
 
-  customizeRender = function(definition) {
+  Luca.View.renderWrapper = function(definition) {
     var _base;
     _base = definition.render;
     _base || (_base = Luca.View.prototype.$attach);
@@ -792,7 +1441,7 @@
           this.deferrable = this.collection;
         }
         target || (target = this.deferrable);
-        trigger = this.deferrable_event ? this.deferrable_event : "reset";
+        trigger = this.deferrable_event ? this.deferrable_event : Luca.View.deferrableEvent;
         deferred = function() {
           _base.call(view);
           return view.trigger("after:render", view);
@@ -820,11 +1469,126 @@
     return definition;
   };
 
+  bindAllEventHandlers = function() {
+    var _this = this;
+    return _(this.events).each(function(handler, event) {
+      if (_.isString(handler)) return _.bindAll(_this, handler);
+    });
+  };
+
+  registerApplicationEvents = function() {
+    var app, eventTrigger, handler, _len, _ref, _ref2, _results;
+    if (_.isEmpty(this.applicationEvents)) return;
+    app = this.app;
+    if (_.isString(app) || _.isUndefined(app)) {
+      app = (_ref = Luca.Application) != null ? typeof _ref.get === "function" ? _ref.get(app) : void 0 : void 0;
+    }
+    if (!Luca.supportsEvents(app)) {
+      throw "Error binding to the application object on " + (this.name || this.cid);
+    }
+    _ref2 = this.applicationEvents;
+    _results = [];
+    for (handler = 0, _len = _ref2.length; handler < _len; handler++) {
+      eventTrigger = _ref2[handler];
+      if (_.isString(handler)) handler = this[handler];
+      if (!_.isFunction(handler)) {
+        throw "Error registering application event " + eventTrigger + " on " + (this.name || this.cid);
+      }
+      _results.push(app.on(eventTrigger, handler));
+    }
+    return _results;
+  };
+
+  registerCollectionEvents = function() {
+    var collection, eventTrigger, handler, key, manager, signature, _ref, _ref2, _results;
+    if (_.isEmpty(this.collectionEvents)) return;
+    manager = this.collectionManager;
+    if (_.isString(manager) || _.isUndefined(manager)) {
+      manager = Luca.CollectionManager.get(manager);
+    }
+    _ref = this.collectionEvents;
+    _results = [];
+    for (signature in _ref) {
+      handler = _ref[signature];
+      _ref2 = signature.split(" "), key = _ref2[0], eventTrigger = _ref2[1];
+      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 {
+        _results.push(collection.bind(eventTrigger, handler));
+      } catch (e) {
+        console.log("Error Binding To Collection in registerCollectionEvents", this);
+        throw e;
+      }
+    }
+    return _results;
+  };
+
+  setupClassHelpers = function() {
+    var additional, additionalClasses, _i, _len, _results;
+    additionalClasses = _(this.additionalClassNames || []).clone();
+    if (this.wrapperClass != null) this.$wrap(this.wrapperClass);
+    if (_.isString(additionalClasses)) {
+      additionalClasses = additionalClasses.split(" ");
+    }
+    if (this.gridSpan) additionalClasses.push("span" + this.gridSpan);
+    if (this.gridOffset) additionalClasses.push("offset" + this.gridOffset);
+    if (this.gridRowFluid) additionalClasses.push("row-fluid");
+    if (this.gridRow) additionalClasses.push("row");
+    if (additionalClasses == null) return;
+    _results = [];
+    for (_i = 0, _len = additionalClasses.length; _i < _len; _i++) {
+      additional = additionalClasses[_i];
+      _results.push(this.$el.addClass(additional));
+    }
+    return _results;
+  };
+
+  setupStateMachine = function() {
+    var _this = this;
+    this.state = new Backbone.Model(this.defaultState || {});
+    this.set || (this.set = function() {
+      return _this.state.set.apply(_this.state, arguments);
+    });
+    return this.get || (this.get = function() {
+      return _this.state.get.apply(_this.state, arguments);
+    });
+  };
+
+  setupBodyTemplate = function() {
+    var template, templateVars;
+    templateVars = this.bodyTemplateVars ? this.bodyTemplateVars.call(this) : this;
+    if (template = this.bodyTemplate) {
+      this.$el.empty();
+      return Luca.View.prototype.$html.call(this, Luca.template(template, templateVars));
+    }
+  };
+
+  setupTemplate = function() {
+    var _this = this;
+    if (this.template != null) {
+      return this.defer(function() {
+        return _this.$template(_this.template, _this);
+      }).until("before:render");
+    }
+  };
+
   Luca.View.extend = function(definition) {
-    definition = customizeRender(definition);
-    return originalExtend.call(this, definition);
+    var module, _i, _len, _ref;
+    definition = Luca.View.renderWrapper(definition);
+    if ((definition.mixins != null) && _.isArray(definition.mixins)) {
+      _ref = definition.mixins;
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        module = _ref[_i];
+        Luca.decorate(definition)["with"](module);
+      }
+    }
+    return Luca.View._originalExtend.call(this, definition);
   };
 
+  Luca.View.deferrableEvent = "reset";
+
 }).call(this);
 (function() {
   var setupComputedProperties;
@@ -841,6 +1605,7 @@
       this.on("change:" + attr, function() {
         return _this._computed[attr] = _this[attr].call(_this);
       });
+      if (_.isString(dependencies)) dependencies = dependencies.split(',');
       _results.push(_(dependencies).each(function(dep) {
         _this.on("change:" + dep, function() {
           return _this.trigger("change:" + attr);
@@ -1234,60 +1999,10 @@
     loadMask: false,
     loadMaskTemplate: ["components/load_mask"],
     loadMaskTimeout: 3000,
+    mixins: ["LoadMaskable"],
     initialize: function(options) {
-      var _this = this;
       this.options = options != null ? options : {};
-      Luca.View.prototype.initialize.apply(this, arguments);
-      _.bindAll(this, "applyLoadMask", "disableLoadMask");
-      if (this.loadMask === true) {
-        this.defer(function() {
-          _this.$el.addClass('with-mask');
-          if (_this.$('.load-mask').length === 0) {
-            _this.loadMaskTarget().prepend(Luca.template(_this.loadMaskTemplate, _this));
-            return _this.$('.load-mask').hide();
-          }
-        }).until("after:render");
-        this.on("enable:loadmask", this.applyLoadMask);
-        return this.on("disable:loadmask", this.applyLoadMask);
-      }
-    },
-    loadMaskTarget: function() {
-      if (this.loadMaskEl != null) {
-        return this.$(this.loadMaskEl);
-      } else {
-        return this.$bodyEl();
-      }
-    },
-    disableLoadMask: function() {
-      this.$('.load-mask .bar').css("width", "100%");
-      this.$('.load-mask').hide();
-      return clearInterval(this.loadMaskInterval);
-    },
-    enableLoadMask: function() {
-      var maxWidth,
-        _this = this;
-      this.$('.load-mask').show().find('.bar').css("width", "0%");
-      maxWidth = this.$('.load-mask .progress').width();
-      if (maxWidth < 20 && (maxWidth = this.$el.width()) < 20) {
-        maxWidth = this.$el.parent().width();
-      }
-      this.loadMaskInterval = setInterval(function() {
-        var currentWidth, newWidth;
-        currentWidth = _this.$('.load-mask .bar').width();
-        newWidth = currentWidth + 12;
-        return _this.$('.load-mask .bar').css('width', newWidth);
-      }, 200);
-      if (this.loadMaskTimeout == null) return;
-      return _.delay(function() {
-        return _this.disableLoadMask();
-      }, this.loadMaskTimeout);
-    },
-    applyLoadMask: function() {
-      if (this.$('.load-mask').is(":visible")) {
-        return this.disableLoadMask();
-      } else {
-        return this.enableLoadMask();
-      }
+      return Luca.View.prototype.initialize.apply(this, arguments);
     },
     applyStyles: function(styles, body) {
       var setting, target, value;
@@ -1338,6 +2053,9 @@
       if (variables == null) variables = {};
       return this.$html(Luca.template(template, variables));
     },
+    $empty: function() {
+      return this.$bodyEl().empty();
+    },
     $html: function(content) {
       return this.$bodyEl().html(content);
     },
@@ -1365,260 +2083,26 @@
 }).call(this);
 (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);
-(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);
-(function() {
-  Luca.templates || (Luca.templates = {});
-  Luca.templates["components/bootstrap_form_controls"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<div class=\'form-actions\'>\n  <a class=\'btn btn-primary submit-button\'>\n    <i class=\'icon-ok icon-white\'></i>\n    Save Changes\n  </a>\n  <a class=\'btn reset-button cancel-button\'>\n    <i class=\'icon-remove\'></i>\n    Cancel\n  </a>\n</div>\n');}return __p.join('');};
-}).call(this);
-(function() {
-  Luca.templates || (Luca.templates = {});
-  Luca.templates["components/collection_loader_view"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<div class=\'modal\' id=\'progress-model\' style=\'display: none;\'>\n  <div class=\'progress progress-info progress-striped active\'>\n    <div class=\'bar\' style=\'width: 0%;\'></div>\n  </div>\n  <div class=\'message\'>\n    Initializing...\n  </div>\n</div>\n');}return __p.join('');};
-}).call(this);
-(function() {
-  Luca.templates || (Luca.templates = {});
-  Luca.templates["components/form_alert"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<div class=\'', className ,'\'>\n  <a class=\'close\' data-dismiss=\'alert\' href=\'#\'>x</a>\n  ', message ,'\n</div>\n');}return __p.join('');};
-}).call(this);
-(function() {
-  Luca.templates || (Luca.templates = {});
-  Luca.templates["components/grid_view"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<div class=\'luca-ui-g-view-wrapper\'>\n  <div class=\'g-view-header\'></div>\n  <div class=\'luca-ui-g-view-body\'>\n    <table cellpadding=\'0\' cellspacing=\'0\' class=\'luca-ui-g-view scrollable-table\' width=\'100%\'>\n      <thead class=\'fixed\'></thead>\n      <tbody class=\'scrollable\'></tbody>\n    </table>\n  </div>\n  <div class=\'luca-ui-g-view-footer\'></div>\n</div>\n');}return __p.join('');};
-}).call(this);
-(function() {
-  Luca.templates || (Luca.templates = {});
-  Luca.templates["components/grid_view_empty_text"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<div class=\'empty-text-wrapper\'>\n  <p>\n    ', text ,'\n  </p>\n</div>\n');}return __p.join('');};
-}).call(this);
-(function() {
-  Luca.templates || (Luca.templates = {});
-  Luca.templates["components/load_mask"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<div class=\'load-mask\'>\n  <div class=\'progress progress-striped active\'>\n    <div class=\'bar\' style=\'width:1%\'></div>\n  </div>\n</div>\n');}return __p.join('');};
-}).call(this);
-(function() {
-  Luca.templates || (Luca.templates = {});
-  Luca.templates["components/nav_bar"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<div class=\'navbar-inner\'>\n  <div class=\'luca-ui-navbar-body container\'></div>\n</div>\n');}return __p.join('');};
-}).call(this);
-(function() {
-  Luca.templates || (Luca.templates = {});
-  Luca.templates["containers/basic"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<div class=\'', classes ,'\' id=\'', id ,'\' style=\'', style ,'\'></div>\n');}return __p.join('');};
-}).call(this);
-(function() {
-  Luca.templates || (Luca.templates = {});
-  Luca.templates["containers/tab_selector_container"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<div class=\'tab-selector-container\' id=\'', cid ,'-tab-selector\'>\n  <ul class=\'nav nav-tabs\' id=\'', cid ,'-tabs-nav\'>\n    '); for(var i = 0; i < components.length; i++ ) { __p.push('\n    '); var component = components[i];__p.push('\n    <li class=\'tab-selector\' data-target=\'', i ,'\'>\n      <a data-target=\'', i ,'\'>\n        ', component.title ,'\n      </a>\n    </li>\n    '); } __p.push('\n  </ul>\n</div>\n');}return __p.join('');};
-}).call(this);
-(function() {
-  Luca.templates || (Luca.templates = {});
-  Luca.templates["containers/tab_view"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<ul class=\'nav ', navClass ,'\' id=\'', cid ,'-tabs-selector\'></ul>\n<div class=\'tab-content\' id=\'', cid ,'-tab-view-content\'></div>\n');}return __p.join('');};
-}).call(this);
-(function() {
-  Luca.templates || (Luca.templates = {});
-  Luca.templates["containers/toolbar_wrapper"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<div class=\'luca-ui-toolbar-wrapper\' id=\'', id ,'\'></div>\n');}return __p.join('');};
-}).call(this);
-(function() {
-  Luca.templates || (Luca.templates = {});
-  Luca.templates["fields/button_field"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<label>&nbsp</label>\n<input class=\'btn ', input_class ,'\' id=\'', input_id ,'\' style=\'', inputStyles ,'\' type=\'', input_type ,'\' value=\'', input_value ,'\' />\n');}return __p.join('');};
-}).call(this);
-(function() {
-  Luca.templates || (Luca.templates = {});
-  Luca.templates["fields/button_field_link"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<a class=\'btn ', input_class ,'\'>\n  '); if(icon_class.length) { __p.push('\n  <i class=\'', icon_class ,'\'></i>\n  '); } __p.push('\n  ', input_value ,'\n</a>\n');}return __p.join('');};
-}).call(this);
-(function() {
-  Luca.templates || (Luca.templates = {});
-  Luca.templates["fields/checkbox_array"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<div class=\'control-group\'>\n  <label for=\'', input_id ,'\'>\n    ', label ,'\n  </label>\n  <div class=\'controls\'></div>\n</div>\n');}return __p.join('');};
-}).call(this);
-(function() {
-  Luca.templates || (Luca.templates = {});
-  Luca.templates["fields/checkbox_array_item"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<label for=\'', input_id ,'\'>\n  <input id=\'', input_id ,'\' name=\'', input_name ,'\' type=\'checkbox\' value=\'', value ,'\' />\n  ', label ,'\n</label>\n');}return __p.join('');};
-}).call(this);
-(function() {
-  Luca.templates || (Luca.templates = {});
-  Luca.templates["fields/checkbox_field"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<label for=\'', input_id ,'\'>\n  ', label ,'\n  <input name=\'', input_name ,'\' style=\'', inputStyles ,'\' type=\'checkbox\' value=\'', input_value ,'\' />\n</label>\n'); if(helperText) { __p.push('\n<p class=\'helper-text help-block\'>\n  ', helperText ,'\n</p>\n'); } __p.push('\n');}return __p.join('');};
-}).call(this);
-(function() {
-  Luca.templates || (Luca.templates = {});
-  Luca.templates["fields/file_upload_field"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<label for=\'', input_id ,'\'>\n  ', label ,'\n</label>\n<input id=\'', input_id ,'\' name=\'', input_name ,'\' style=\'', inputStyles ,'\' type=\'file\' />\n'); if(helperText) { __p.push('\n<p class=\'helper-text help-block\'>\n  ', helperText ,'\n</p>\n'); } __p.push('\n');}return __p.join('');};
-}).call(this);
-(function() {
-  Luca.templates || (Luca.templates = {});
-  Luca.templates["fields/hidden_field"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<input id=\'', input_id ,'\' name=\'', input_name ,'\' type=\'hidden\' value=\'', input_value ,'\' />\n');}return __p.join('');};
-}).call(this);
-(function() {
-  Luca.templates || (Luca.templates = {});
-  Luca.templates["fields/select_field"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<label for=\'', input_id ,'\'>\n  ', label ,'\n</label>\n<select id=\'', input_id ,'\' name=\'', input_name ,'\' style=\'', inputStyles ,'\'></select>\n'); if(helperText) { __p.push('\n<p class=\'helper-text help-block\'>\n  ', helperText ,'\n</p>\n'); } __p.push('\n');}return __p.join('');};
-}).call(this);
-(function() {
-  Luca.templates || (Luca.templates = {});
-  Luca.templates["fields/text_area_field"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<label for=\'', input_id ,'\'>\n  ', label ,'\n</label>\n<textarea class=\'', input_class ,'\' id=\'', input_id ,'\' name=\'', input_name ,'\' style=\'', inputStyles ,'\'></textarea>\n'); if(helperText) { __p.push('\n<p class=\'helper-text help-block\'>\n  ', helperText ,'\n</p>\n'); } __p.push('\n');}return __p.join('');};
-}).call(this);
-(function() {
-  Luca.templates || (Luca.templates = {});
-  Luca.templates["fields/text_field"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push(''); if(typeof(label)!=="undefined" && (typeof(hideLabel) !== "undefined" && !hideLabel) || (typeof(hideLabel)==="undefined")) {__p.push('\n<label class=\'control-label\' for=\'', input_id ,'\'>\n  ', label ,'\n</label>\n'); } __p.push('\n'); if( typeof(addOn) !== "undefined" ) { __p.push('\n<span class=\'add-on\'>\n  ', addOn ,'\n</span>\n'); } __p.push('\n<input class=\'', input_class ,'\' id=\'', input_id ,'\' name=\'', input_name ,'\' placeholder=\'', placeHolder ,'\' style=\'', inputStyles ,'\' type=\'text\' />\n'); if(helperText) { __p.push('\n<p class=\'helper-text help-block\'>\n  ', helperText ,'\n</p>\n'); } __p.push('\n');}return __p.join('');};
-}).call(this);
-(function() {
-  Luca.templates || (Luca.templates = {});
-  Luca.templates["sample/contents"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('<p>Sample Contents</p>\n');}return __p.join('');};
-}).call(this);
-(function() {
-  Luca.templates || (Luca.templates = {});
-  Luca.templates["sample/welcome"] = function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('welcome.luca\n');}return __p.join('');};
-}).call(this);
-(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("all", function(trigger, one, two) {
-          return console.log("ALL", trigger, one, two);
-        });
-      }
-    }
-
-    Observer.prototype.relay = function() {
-      var args, triggerer;
-      triggerer = arguments[0], args = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
-      console.log("Relaying", trigger, args);
-      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);
-(function() {
-
-  _.def('Luca.core.Field')["extends"]('Luca.View')["with"]({
-    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);
-      this.input_id || (this.input_id = _.uniqueId('field'));
-      this.input_name || (this.input_name = this.name);
-      this.input_class || (this.input_class = "");
-      this.helperText || (this.helperText = "");
-      if (this.required && !((_ref = this.label) != null ? _ref.match(/^\*/) : void 0)) {
-        this.label || (this.label = "*" + this.label);
+  _.def('Luca.core.Field')["extends"]('Luca.View')["with"]({
+    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);
+      this.input_id || (this.input_id = _.uniqueId('field'));
+      this.input_name || (this.input_name = this.name);
+      this.input_class || (this.input_class = "");
+      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 = "");
+      this.input_value || (this.input_value = this.value || "");
       if (this.disabled) this.disable();
       this.updateState(this.state);
       this.placeHolder || (this.placeHolder = "");
@@ -1627,7 +2111,7 @@
     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));
+      this.$template(this.template, this);
       return this.input = $('input', this.el);
     },
     change_handler: function(e) {
@@ -1640,7 +2124,19 @@
       return $("input", this.el).attr('disabled', false);
     },
     getValue: function() {
-      return this.input.attr('value');
+      var raw;
+      raw = this.input.attr('value');
+      if (_.str.isBlank(raw)) return raw;
+      switch (this.valueType) {
+        case "integer":
+          return parseInt(raw);
+        case "string":
+          return "" + raw;
+        case "float":
+          return parseFloat(raw);
+        default:
+          return raw;
+      }
     },
     render: function() {
       return $(this.container).append(this.$el);
@@ -1681,7 +2177,7 @@
       "class": (panel != null ? panel.classes : void 0) || this.componentClass,
       id: "" + this.cid + "-" + panelIndex,
       style: style_declarations.join(';'),
-      "data-luca-owner": this.name || this.cid
+      "data-luca-parent": this.name || this.cid
     };
     if (this.customizeContainerEl != null) {
       config = this.customizeContainerEl(config, panel, panelIndex);
@@ -1710,6 +2206,7 @@
       this.options = options != null ? options : {};
       _.extend(this, this.options);
       this.setupHooks(["before:components", "before:render:components", "before:layout", "after:components", "after:layout", "first:activation"]);
+      this.components || (this.components = this.fields || (this.fields = this.pages || (this.pages = this.cards)));
       return Luca.View.prototype.initialize.apply(this, arguments);
     },
     beforeRender: function() {
@@ -1741,30 +2238,38 @@
         }
       }
       return _(this.components).each(function(component, index) {
-        var container, panel, _ref2;
-        container = (_ref2 = _this.componentContainers) != null ? _ref2[index] : void 0;
-        container["class"] = container["class"] || container.className || container.classes;
-        if (_this.appendContainers) {
-          panel = _this.make(_this.componentTag, container, '');
+        var ce, componentContainerElement, panel, _ref2;
+        ce = componentContainerElement = (_ref2 = _this.componentContainers) != null ? _ref2[index] : void 0;
+        ce["class"] = ce["class"] || ce.className || ce.classes;
+        if (_this.generateComponentElements) {
+          panel = _this.make(_this.componentTag, componentContainerElement, '');
           _this.$append(panel);
         }
         if (component.container == null) {
-          if (_this.appendContainers) component.container = "#" + container.id;
+          if (_this.generateComponentElements) {
+            component.container = "#" + componentContainerElement.id;
+          }
           return component.container || (component.container = _this.$bodyEl());
         }
       });
     },
     createComponents: function() {
-      var map,
+      var container, map,
         _this = this;
       if (this.componentsCreated === true) return;
       map = this.componentIndex = {
         name_index: {},
         cid_index: {}
       };
+      container = this;
       this.components = _(this.components).map(function(object, index) {
-        var component;
-        component = Luca.isBackboneView(object) ? object : (object.type || (object.type = object.ctype), !(object.type != null) ? object.components != null ? object.type = object.ctype = 'container' : object.type = object.ctype = Luca.defaultComponentType : void 0, Luca.util.lazyComponent(object));
+        var component, created;
+        component = Luca.isBackboneView(object) ? object : (object.type || (object.type = object.ctype), !(object.type != null) ? object.components != null ? object.type = object.ctype = 'container' : object.type = object.ctype = Luca.defaultComponentType : void 0, object = _.defaults(object, container.defaults || {}), created = Luca.util.lazyComponent(object));
+        if (_.isString(component.getter)) {
+          container[component.getter] = (function() {
+            return component;
+          });
+        }
         if (!component.container && component.options.container) {
           component.container = component.options.container;
         }
@@ -1779,15 +2284,16 @@
       return map;
     },
     renderComponents: function(debugMode) {
-      var _this = this;
+      var container;
       this.debugMode = debugMode != null ? debugMode : "";
       this.debug("container render components");
+      container = this;
       return _(this.components).each(function(component) {
         component.getParent = function() {
-          return _this;
+          return container;
         };
-        $(component.container).append($(component.el));
         try {
+          $(component.container).append(component.el);
           return component.render();
         } catch (e) {
           console.log("Error Rendering Component " + (component.name || component.cid), component);
@@ -1820,20 +2326,8 @@
     invoke: function(method) {
       return _(this.components).invoke(method);
     },
-    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) {
-          matches.push(typeof component.select === "function" ? component.select(attribute, value, true) : void 0);
-        }
-        return _.compact(matches);
-      });
-      return _.flatten(components);
+    map: function(fn) {
+      return _(this.components).map(fn);
     },
     componentEvents: {},
     registerComponentEvents: function() {
@@ -1895,32 +2389,63 @@
       return this.components[this.activeItem];
     },
     componentElements: function() {
-      return $(">." + this.componentClass, this.el);
+      return this.$("[data-luca-parent='" + (this.name || this.cid) + "']");
     },
     getComponent: function(needle) {
       return this.components[needle];
     },
-    rootComponent: function() {
+    isRootComponent: function() {
       return !(this.getParent != null);
     },
     getRootComponent: function() {
-      if (this.rootComponent()) {
+      if (this.isRootComponent()) {
         return this;
       } else {
         return this.getParent().getRootComponent();
       }
+    },
+    selectByAttribute: 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) {
+          matches.push(typeof component.selectByAttribute === "function" ? component.selectByAttribute(attribute, value, true) : void 0);
+        }
+        return _.compact(matches);
+      });
+      return _.flatten(components);
+    },
+    select: function(attribute, value, deep) {
+      if (deep == null) deep = false;
+      console.log("Container.select will be replaced by selectByAttribute in 1.0");
+      return Luca.core.Container.prototype.selectByAttribute.apply(this, arguments);
     }
   });
 
+  Luca.core.Container.componentRenderer = function(container, component) {
+    var attachMethod;
+    attachMethod = $(component.container)[component.attachWith || "append"];
+    return attachMethod(component.render().el);
+  };
+
 }).call(this);
 (function() {
+  var guessCollectionClass, handleInitialCollections, loadInitialCollections;
 
   Luca.CollectionManager = (function() {
 
     CollectionManager.prototype.name = "primary";
 
+    CollectionManager.prototype.collectionNamespace = Luca.Collection.namespace;
+
     CollectionManager.prototype.__collections = {};
 
+    CollectionManager.prototype.relayEvents = true;
+
     function CollectionManager(options) {
       var existing, manager, _base, _base2;
       this.options = options != null ? options : {};
@@ -1938,21 +2463,7 @@
         return Luca.CollectionManager.instances[name];
       };
       this.state = new Luca.Model();
-      if (this.initialCollections) {
-        this.state.set({
-          loaded_collections_count: 0,
-          collections_count: this.initialCollections.length
-        });
-        this.state.bind("change:loaded_collections_count", this.collectionCountDidChange);
-        if (this.useProgressLoader) {
-          this.loaderView || (this.loaderView = new Luca.components.CollectionLoaderView({
-            manager: this,
-            name: "collection_loader_view"
-          }));
-        }
-        this.loadInitialCollections();
-      }
-      this;
+      if (this.initialCollections) handleInitialCollections.call(this);
     }
 
     CollectionManager.prototype.add = function(key, collection) {
@@ -1965,19 +2476,23 @@
     };
 
     CollectionManager.prototype.create = function(key, collectionOptions, initialModels) {
-      var CollectionClass, collection;
+      var CollectionClass, collection, collectionManager;
       if (collectionOptions == null) collectionOptions = {};
       if (initialModels == null) initialModels = [];
       CollectionClass = collectionOptions.base;
-      CollectionClass || (CollectionClass = this.guessCollectionClass(key));
+      CollectionClass || (CollectionClass = guessCollectionClass.call(this, key));
       if (collectionOptions.private) collectionOptions.name = "";
       collection = new CollectionClass(initialModels, collectionOptions);
       this.add(key, collection);
+      collectionManager = this;
+      if (this.relayEvents === true) {
+        this.bind("*", function() {
+          return console.log("Relay Events on Collection Manager *", collection, arguments);
+        });
+      }
       return collection;
     };
 
-    CollectionManager.prototype.collectionNamespace = Luca.Collection.namespace;
-
     CollectionManager.prototype.currentScope = function() {
       var current_scope, _base;
       if (current_scope = this.getScope()) {
@@ -1999,48 +2514,28 @@
       return;
     };
 
+    CollectionManager.prototype.destroy = function(key) {
+      var c;
+      c = this.get(key);
+      delete this.currentScope()[key];
+      return c;
+    };
+
     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, guesses, _ref;
-      classified = Luca.util.classify(key);
-      guess = (this.collectionNamespace || (window || global))[classified];
-      guess || (guess = (this.collectionNamespace || (window || global))["" + classified + "Collection"]);
-      if (!(guess != null) && ((_ref = Luca.Collection.namespaces) != null ? _ref.length : void 0) > 0) {
-        guesses = _(Luca.Collection.namespaces.reverse()).map(function(namespace) {
-          return Luca.util.resolve("" + namespace + "." + classified) || Luca.util.resolve("" + namespace + "." + classified + "Collection");
-        });
-        guesses = _(guesses).compact();
-        if (guesses.length > 0) guess = guesses[0];
+    CollectionManager.prototype.collectionCountDidChange = function() {
+      if (this.allCollectionsLoaded()) {
+        this.trigger("all_collections_loaded");
+        return this.trigger("initial:load");
       }
-      return guess;
-    };
-
-    CollectionManager.prototype.loadInitialCollections = function() {
-      var collectionDidLoad,
-        _this = this;
-      collectionDidLoad = function(collection) {
-        collection.unbind("reset");
-        return _this.trigger("collection_loaded", collection.name);
-      };
-      return _(this.initialCollections).each(function(name) {
-        var collection;
-        collection = _this.getOrCreate(name);
-        collection.bind("reset", function() {
-          return collectionDidLoad(collection);
-        });
-        return collection.fetch();
-      });
     };
 
-    CollectionManager.prototype.collectionCountDidChange = function() {
-      if (this.totalCollectionsCount() === this.loadedCollectionsCount()) {
-        return this.trigger("all_collections_loaded");
-      }
+    CollectionManager.prototype.allCollectionsLoaded = function() {
+      return this.totalCollectionsCount() === this.loadedCollectionsCount();
     };
 
     CollectionManager.prototype.totalCollectionsCount = function() {
@@ -2065,10 +2560,64 @@
     return Luca.CollectionManager.instances = {};
   };
 
-}).call(this);
-(function() {
-
-  Luca.SocketManager = (function() {
+  guessCollectionClass = function(key) {
+    var classified, guess, guesses, _ref;
+    classified = Luca.util.classify(key);
+    guess = (this.collectionNamespace || (window || global))[classified];
+    guess || (guess = (this.collectionNamespace || (window || global))["" + classified + "Collection"]);
+    if (!(guess != null) && ((_ref = Luca.Collection.namespaces) != null ? _ref.length : void 0) > 0) {
+      guesses = _(Luca.Collection.namespaces.reverse()).map(function(namespace) {
+        return Luca.util.resolve("" + namespace + "." + classified) || Luca.util.resolve("" + namespace + "." + classified + "Collection");
+      });
+      guesses = _(guesses).compact();
+      if (guesses.length > 0) guess = guesses[0];
+    }
+    return guess;
+  };
+
+  loadInitialCollections = function() {
+    var collectionDidLoad,
+      _this = this;
+    collectionDidLoad = function(collection) {
+      var current;
+      current = _this.state.get("loaded_collections_count");
+      _this.state.set("loaded_collections_count", current + 1);
+      _this.trigger("collection_loaded", collection.name);
+      return collection.unbind("reset");
+    };
+    return _(this.initialCollections).each(function(name) {
+      var collection;
+      collection = _this.getOrCreate(name);
+      collection.once("reset", function() {
+        return collectionDidLoad(collection);
+      });
+      return collection.fetch();
+    });
+  };
+
+  handleInitialCollections = function() {
+    var _this = this;
+    this.state.set({
+      loaded_collections_count: 0,
+      collections_count: this.initialCollections.length
+    });
+    this.state.bind("change:loaded_collections_count", function() {
+      return _this.collectionCountDidChange();
+    });
+    if (this.useProgressLoader) {
+      this.loaderView || (this.loaderView = new Luca.components.CollectionLoaderView({
+        manager: this,
+        name: "collection_loader_view"
+      }));
+    }
+    loadInitialCollections.call(this);
+    return this;
+  };
+
+}).call(this);
+(function() {
+
+  Luca.SocketManager = (function() {
 
     function SocketManager(options) {
       this.options = options != null ? options : {};
@@ -2136,12 +2685,13 @@
     components: [],
     initialize: function(options) {
       this.options = options != null ? options : {};
+      console.log("Column Views are deprecated in favor of just using grid css on a normal container");
       Luca.core.Container.prototype.initialize.apply(this, arguments);
       return this.setColumnWidths();
     },
     componentClass: 'luca-ui-column',
     containerTemplate: "containers/basic",
-    appendContainers: true,
+    generateComponentElements: true,
     autoColumnWidths: function() {
       var widths,
         _this = this;
@@ -2173,33 +2723,32 @@
 
 }).call(this);
 (function() {
+  var component;
 
-  _.def("Luca.containers.CardView")["extends"]("Luca.core.Container")["with"]({
-    componentType: 'card_view',
+  component = Luca.define("Luca.containers.CardView");
+
+  component["extends"]("Luca.core.Container");
+
+  component.defaults({
     className: 'luca-ui-card-view-wrapper',
     activeCard: 0,
     components: [],
     hooks: ['before:card:switch', 'after:card:switch'],
     componentClass: 'luca-ui-card',
-    appendContainers: true,
+    generateComponentElements: true,
     initialize: function(options) {
       this.options = options;
       Luca.core.Container.prototype.initialize.apply(this, arguments);
-      return this.setupHooks(this.hooks);
+      this.setupHooks(this.hooks);
+      return this.components || (this.components = this.pages || (this.pages = this.cards));
     },
     prepareComponents: function() {
-      var _ref,
-        _this = this;
+      var _ref;
       if ((_ref = Luca.core.Container.prototype.prepareComponents) != null) {
         _ref.apply(this, arguments);
       }
-      return _(this.components).each(function(component, index) {
-        if (index === _this.activeCard) {
-          return $(component.container).show();
-        } else {
-          return $(component.container).hide();
-        }
-      });
+      this.componentElements().hide();
+      return this.activeComponentElement().show();
     },
     activeComponentElement: function() {
       return this.componentElements().eq(this.activeCard);
@@ -2211,13 +2760,27 @@
       containerEl.style += panelIndex === this.activeCard ? "display:block;" : "display:none;";
       return containerEl;
     },
+    atFirst: function() {
+      return this.activeCard === 0;
+    },
+    atLast: function() {
+      return this.activeCard === this.components.length - 1;
+    },
+    next: function() {
+      if (this.atLast()) return;
+      return this.activate(this.activeCard + 1);
+    },
+    previous: function() {
+      if (this.atFirst()) return;
+      return this.activate(this.activeCard - 1);
+    },
     cycle: function() {
       var nextIndex;
-      nextIndex = this.activeCard < this.components.length - 1 ? this.activeCard + 1 : 0;
+      nextIndex = this.atLast() ? 0 : this.activeCard + 1;
       return this.activate(nextIndex);
     },
     find: function(name) {
-      return this.findComponentByName(name, true);
+      return Luca(name);
     },
     firstActivation: function() {
       return this.activeComponent().trigger("first:activation", this, this.activeComponent());
@@ -2279,10 +2842,11 @@
 }).call(this);
 (function() {
 
-  _.def("Luca.ModalView")["extends"]("Luca.View")["with"]({
+  _.def("Luca.ModalView")["extends"]("Luca.core.Container")["with"]({
     closeOnEscape: true,
     showOnInitialize: false,
     backdrop: false,
+    className: "luca-ui-container modal",
     container: function() {
       return $('body');
     },
@@ -2299,16 +2863,24 @@
       this.$el.addClass('modal');
       if (this.fade === true) this.$el.addClass('fade');
       $('body').append(this.$el);
-      return this.$el.modal({
+      this.$el.modal({
         backdrop: this.backdrop === true,
         keyboard: this.closeOnEscape === true,
         show: this.showOnInitialize === true
       });
+      return this;
     }
   });
 
   _.def("Luca.containers.ModalView")["extends"]("Luca.ModalView")["with"]();
 
+}).call(this);
+(function() {
+
+  _.def("Luca.PageView")["extends"]("Luca.containers.CardView")["with"]({
+    version: 2
+  });
+
 }).call(this);
 (function() {
   var buildButton, make, prepareButtons;
@@ -2501,11 +3073,12 @@
       return (_ref = Luca.containers.CardView.prototype.beforeLayout) != null ? _ref.apply(this, arguments) : void 0;
     },
     afterRender: function() {
-      var _ref;
+      var tabContainerId, _ref;
       if ((_ref = Luca.containers.CardView.prototype.afterRender) != null) {
         _ref.apply(this, arguments);
       }
-      this.registerEvent("click #" + this.cid + "-tabs-selector li a", "select");
+      tabContainerId = this.tabContainer().attr("id");
+      this.registerEvent("click #" + tabContainerId + " li a", "select");
       if (Luca.enableBootstrap && (this.tab_position === "left" || this.tab_position === "right")) {
         this.tabContainerWrapper().addClass("span2");
         return this.tabContentWrapper().addClass("span9");
@@ -2516,7 +3089,9 @@
       tabView = this;
       return this.each(function(component, index) {
         var icon, link, selector, _ref;
-        if (component.tabIcon) icon = "<i class='icon-" + component.tabIcon;
+        if (component.tabIcon) {
+          icon = "<i class='icon-" + component.tabIcon + "'></i>";
+        }
         link = "<a href='#'>" + (icon || '') + " " + component.title + "</a>";
         selector = tabView.make("li", {
           "class": "tab-selector",
@@ -2569,17 +3144,38 @@
     additionalClassNames: 'luca-ui-viewport',
     fullscreen: true,
     fluid: false,
-    wrapperClass: 'row',
     initialize: function(options) {
       this.options = options != null ? options : {};
       _.extend(this, this.options);
       if (Luca.enableBootstrap === true) {
-        if (this.fluid === true) {
-          this.wrapperClass = "row-fluid fluid-viewport-wrapper";
-        }
+        this.wrapperClass = this.fluid === true ? Luca.containers.Viewport.fluidWrapperClass : Luca.containers.Viewport.defaultWrapperClass;
       }
       Luca.core.Container.prototype.initialize.apply(this, arguments);
-      if (this.fullscreen) return $('html,body').addClass('luca-ui-fullscreen');
+      if (this.fullscreen === true) return this.enableFullscreen();
+    },
+    enableFluid: function() {
+      return this.enableWrapper();
+    },
+    disableFluid: function() {
+      return this.disableWrapper();
+    },
+    enableWrapper: function() {
+      if (this.wrapperClass != null) {
+        return this.$el.parent().addClass(this.wrapperClass);
+      }
+    },
+    disableWrapper: function() {
+      if (this.wrapperClass != null) {
+        return this.$el.parent().removeClass(this.wrapperClass);
+      }
+    },
+    enableFullscreen: function() {
+      $('html,body').addClass('luca-ui-fullscreen');
+      return this.$el.addClass('fullscreen-enabled');
+    },
+    disableFullscreen: function() {
+      $('html,body').removeClass('luca-ui-fullscreen');
+      return this.$el.removeClass('fullscreen-enabled');
     },
     beforeRender: function() {
       var _ref;
@@ -2589,6 +3185,12 @@
       if (this.topNav != null) this.renderTopNavigation();
       if (this.bottomNav != null) return this.renderBottomNavigation();
     },
+    height: function() {
+      return this.$el.height();
+    },
+    width: function() {
+      return this.$el.width();
+    },
     afterRender: function() {
       var _ref;
       if ((_ref = Luca.containers.CardView.prototype.after) != null) {
@@ -2616,7 +3218,2080 @@
     renderBottomNavigation: function() {}
   });
 
+  Luca.containers.Viewport.defaultWrapperClass = 'row';
+
+  Luca.containers.Viewport.fluidWrapperClass = 'row-fluid';
+
+}).call(this);
+(function() {
+
+  _.def('Luca.components.Template')["extends"]('Luca.View')["with"]({
+    initialize: function(options) {
+      this.options = options != null ? options : {};
+      console.log("The Use of Luca.components.Template directly is being DEPRECATED");
+      return Luca.View.prototype.initialize.apply(this, arguments);
+    }
+  });
+
+}).call(this);
+(function() {
+  var startHistory;
+
+  startHistory = function() {
+    return Backbone.history.start();
+  };
+
+  _.def('Luca.Application')["extends"]('Luca.containers.Viewport')["with"]({
+    name: "MyApp",
+    defaultState: {},
+    autoBoot: false,
+    autoStartHistory: "before:render",
+    useCollectionManager: true,
+    collectionManager: {},
+    collectionManagerClass: "Luca.CollectionManager",
+    plugin: false,
+    useController: true,
+    useKeyHandler: false,
+    keyEvents: {},
+    components: [
+      {
+        ctype: 'template',
+        name: 'welcome',
+        template: 'sample/welcome',
+        templateContainer: "Luca.templates"
+      }
+    ],
+    initialize: function(options) {
+      var alreadyRunning, app, appName, _base,
+        _this = this;
+      this.options = options != null ? options : {};
+      app = this;
+      appName = this.name;
+      alreadyRunning = typeof Luca.getApplication === "function" ? Luca.getApplication() : void 0;
+      (_base = Luca.Application).instances || (_base.instances = {});
+      Luca.Application.instances[appName] = app;
+      Luca.containers.Viewport.prototype.initialize.apply(this, arguments);
+      this.state = new Luca.Model(this.defaultState);
+      if (this.useController === true) this.setupMainController();
+      this.setupCollectionManager();
+      this.defer(function() {
+        return app.render();
+      }).until(this, "ready");
+      this.setupRouter();
+      if (this.useKeyRouter === true) {
+        console.log("The useKeyRouter property is being deprecated. switch to useKeyHandler instead");
+      }
+      if ((this.useKeyHandler === true || this.useKeyRouter === true) && (this.keyEvents != null)) {
+        this.setupKeyHandler();
+      }
+      if (!(this.plugin === true || alreadyRunning)) {
+        Luca.getApplication = function(name) {
+          if (name == null) return app;
+          return Luca.Application.instances[name];
+        };
+      }
+      if (this.autoBoot) {
+        if (Luca.util.resolve(this.name)) {
+          throw "Attempting to override window." + this.name + " when it already exists";
+        }
+        return $(function() {
+          window[appName] = app;
+          return app.boot();
+        });
+      }
+    },
+    activeView: function() {
+      var active;
+      if (active = this.activeSubSection()) {
+        return this.view(active);
+      } else {
+        return this.view(this.activeSection());
+      }
+    },
+    activeSection: function() {
+      return this.get("active_section");
+    },
+    activeSubSection: function() {
+      return this.get("active_sub_section");
+    },
+    activePages: function() {
+      var _this = this;
+      return this.$('.luca-ui-controller').map(function(index, element) {
+        return $(element).data('active-section');
+      });
+    },
+    boot: function() {
+      return this.trigger("ready");
+    },
+    collection: function() {
+      return this.collectionManager.getOrCreate.apply(this.collectionManager, arguments);
+    },
+    get: function(attribute) {
+      return this.state.get(attribute);
+    },
+    set: function(attribute, value, options) {
+      return this.state.set.apply(this.state, arguments);
+    },
+    view: function(name) {
+      return Luca.cache(name);
+    },
+    navigate_to: function(component_name, callback) {
+      return this.getMainController().navigate_to(component_name, callback);
+    },
+    getMainController: function() {
+      if (this.useController === true) return this.components[0];
+      return Luca.cache('main_controller');
+    },
+    keyHandler: function(e) {
+      var control, isInputEvent, keyEvent, keyname, meta, source, _ref;
+      if (!(e && this.keyEvents)) return;
+      isInputEvent = $(e.target).is('input') || $(e.target).is('textarea');
+      if (isInputEvent) return;
+      keyname = Luca.keyMap[e.keyCode];
+      if (!keyname) return;
+      meta = (e != null ? e.metaKey : void 0) === true;
+      control = (e != null ? e.ctrlKey : void 0) === true;
+      source = this.keyEvents;
+      source = meta ? this.keyEvents.meta : source;
+      source = control ? this.keyEvents.control : source;
+      source = meta && control ? this.keyEvents.meta_control : source;
+      if (keyEvent = source != null ? source[keyname] : void 0) {
+        if ((this[keyEvent] != null) && _.isFunction(this[keyEvent])) {
+          return (_ref = this[keyEvent]) != null ? _ref.call(this) : void 0;
+        } else {
+          return this.trigger(keyEvent, e, keyname);
+        }
+      }
+    },
+    setupControllerBindings: function() {
+      var app, _ref, _ref2,
+        _this = this;
+      app = this;
+      if ((_ref = this.getMainController()) != null) {
+        _ref.bind("after:card:switch", function(previous, current) {
+          _this.state.set({
+            active_section: current.name
+          });
+          return app.trigger("page:change");
+        });
+      }
+      return (_ref2 = this.getMainController()) != null ? _ref2.each(function(component) {
+        if (component.ctype.match(/controller$/)) {
+          return component.bind("after:card:switch", function(previous, current) {
+            _this.state.set({
+              active_sub_section: current.name
+            });
+            return app.trigger("sub:page:change");
+          });
+        }
+      }) : void 0;
+    },
+    setupMainController: function() {
+      var definedComponents;
+      if (this.useController === true) {
+        definedComponents = this.components || [];
+        this.components = [
+          {
+            ctype: 'controller',
+            name: "main_controller",
+            components: definedComponents
+          }
+        ];
+        return this.defer(this.setupControllerBindings, false).until("after:components");
+      }
+    },
+    setupCollectionManager: function() {
+      var collectionManagerOptions, _base, _ref, _ref2;
+      if (this.useCollectionManager === true) {
+        if (_.isString(this.collectionManagerClass)) {
+          this.collectionManagerClass = Luca.util.resolve(this.collectionManagerClass);
+        }
+        collectionManagerOptions = this.collectionManagerOptions;
+        if (_.isObject(this.collectionManager) && !_.isFunction((_ref = this.collectionManager) != null ? _ref.get : void 0)) {
+          collectionManagerOptions = this.collectionManager;
+          this.collectionManager = void 0;
+        }
+        if (_.isString(this.collectionManager)) {
+          collectionManagerOptions = {
+            name: this.collectionManager
+          };
+        }
+        this.collectionManager = typeof (_base = Luca.CollectionManager).get === "function" ? _base.get(collectionManagerOptions.name) : void 0;
+        if (!_.isFunction((_ref2 = this.collectionManager) != null ? _ref2.get : void 0)) {
+          return this.collectionManager = new this.collectionManagerClass(collectionManagerOptions);
+        }
+      }
+    },
+    setupRouter: function() {
+      var app, routerClass;
+      app = this;
+      if (_.isString(this.router)) {
+        routerClass = Luca.util.resolve(this.router);
+        this.router = new routerClass({
+          app: app
+        });
+      }
+      if (this.router && this.autoStartHistory) {
+        if (this.autoStartHistory === true) {
+          this.autoStartHistory = "before:render";
+        }
+        return this.defer(startHistory, false).until(this, this.autoStartHistory);
+      }
+    },
+    setupKeyHandler: function() {
+      var handler, keyEvent, _base, _i, _len, _ref, _results;
+      if (!this.keyEvents) return;
+      (_base = this.keyEvents).control_meta || (_base.control_meta = {});
+      if (this.keyEvents.meta_control) {
+        _.extend(this.keyEvents.control_meta, this.keyEvents.meta_control);
+      }
+      handler = _.bind(this.keyHandler, this);
+      _ref = this.keypressEvents || ["keydown"];
+      _results = [];
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        keyEvent = _ref[_i];
+        _results.push($(document).on(keyEvent, handler));
+      }
+      return _results;
+    }
+  });
+
+}).call(this);
+(function() {
+
+  _.def('Luca.components.Toolbar')["extends"]('Luca.core.Container')["with"]({
+    className: 'luca-ui-toolbar 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);
+    }
+  });
+
+}).call(this);
+(function() {
+
+  _.def('Luca.components.CollectionLoaderView')["extends"]('Luca.components.Template')["with"]({
+    className: 'luca-ui-collection-loader-view',
+    template: "components/collection_loader_view",
+    initialize: function(options) {
+      this.options = options != null ? options : {};
+      Luca.components.Template.prototype.initialize.apply(this, arguments);
+      this.container || (this.container = $('body'));
+      this.manager || (this.manager = Luca.CollectionManager.get());
+      return this.setupBindings();
+    },
+    modalContainer: function() {
+      return $("#progress-modal", this.el);
+    },
+    setupBindings: function() {
+      var _this = this;
+      this.manager.bind("collection_loaded", function(name) {
+        var collectionName, loaded, progress, total;
+        loaded = _this.manager.loadedCollectionsCount();
+        total = _this.manager.totalCollectionsCount();
+        progress = parseInt((loaded / total) * 100);
+        collectionName = _.string.titleize(_.string.humanize(name));
+        _this.modalContainer().find('.progress .bar').attr("style", "width: " + progress + "%;");
+        return _this.modalContainer().find('.message').html("Loaded " + collectionName + "...");
+      });
+      return this.manager.bind("all_collections_loaded", function() {
+        _this.modalContainer().find('.message').html("All done!");
+        return _.delay(function() {
+          return _this.modalContainer().modal('hide');
+        }, 400);
+      });
+    }
+  });
+
+}).call(this);
+(function() {
+  var collectionView, make, setupChangeObserver;
+
+  collectionView = Luca.define("Luca.components.CollectionView");
+
+  collectionView["extends"]("Luca.components.Panel");
+
+  collectionView.behavesAs("LoadMaskable", "Filterable", "Paginatable");
+
+  collectionView.defaultsTo({
+    tagName: "ol",
+    className: "luca-ui-collection-view",
+    bodyClassName: "collection-ui-panel",
+    itemTemplate: void 0,
+    itemRenderer: void 0,
+    itemTagName: 'li',
+    itemClassName: 'collection-item',
+    hooks: ["before:refresh", "empty:results", "after:refresh"],
+    initialize: function(options) {
+      var _this = this;
+      this.options = options != null ? options : {};
+      _.extend(this, this.options);
+      _.bindAll(this, "refresh");
+      if (!((this.collection != null) || this.options.collection)) {
+        throw "Collection Views must specify a collection";
+      }
+      if (!((this.itemTemplate != null) || (this.itemRenderer != null) || (this.itemProperty != null))) {
+        throw "Collection Views must specify an item template or item renderer function";
+      }
+      Luca.components.Panel.prototype.initialize.apply(this, arguments);
+      if (_.isString(this.collection) && Luca.CollectionManager.get()) {
+        this.collection = Luca.CollectionManager.get().getOrCreate(this.collection);
+      }
+      if (!Luca.isBackboneCollection(this.collection)) {
+        throw "Collection Views must have a valid backbone collection";
+        this.collection.on("before:fetch", function() {
+          if (_this.loadMask === true) return _this.trigger("enable:loadmask");
+        });
+        this.collection.bind("reset", function() {
+          _this.trigger("collection:change");
+          if (_this.loadMask === true) return _this.trigger("disable:loadmask");
+        });
+        this.collection.bind("remove", function() {
+          return _this.trigger("collection:change");
+        });
+        this.collection.bind("add", function() {
+          return _this.trigger("collection:change");
+        });
+        if (this.observeChanges === true) setupChangeObserver.call(this);
+      }
+      if (this.autoRefreshOnModelsPresent !== false) {
+        this.defer(function() {
+          if (_this.collection.length > 0) return _this.refresh();
+        }).until("after:render");
+      }
+      return this.on("collection:change", this.refresh, this);
+    },
+    attributesForItem: function(item, model) {
+      return _.extend({}, {
+        "class": this.itemClassName,
+        "data-index": item.index,
+        "data-model-id": item.model.get('id')
+      });
+    },
+    contentForItem: function(item) {
+      var content, templateFn;
+      if (item == null) item = {};
+      if ((this.itemTemplate != null) && (templateFn = Luca.template(this.itemTemplate))) {
+        return content = templateFn.call(this, item);
+      }
+      if ((this.itemRenderer != null) && _.isFunction(this.itemRenderer)) {
+        return content = this.itemRenderer.call(this, item, item.model, item.index);
+      }
+      if (this.itemProperty && (item.model != null)) {
+        return content = item.model.read(this.itemProperty);
+      }
+      return "";
+    },
+    makeItem: function(model, index) {
+      var attributes, content, item;
+      item = this.prepareItem != null ? this.prepareItem.call(this, model, index) : {
+        model: model,
+        index: index
+      };
+      attributes = this.attributesForItem(item, model);
+      content = this.contentForItem(item);
+      try {
+        return make(this.itemTagName, attributes, content);
+      } catch (e) {
+        return console.log("Error generating DOM element for CollectionView", this, model, index);
+      }
+    },
+    getCollection: function() {
+      return this.collection;
+    },
+    getQuery: function() {
+      return {};
+    },
+    getQueryOptions: function() {
+      return {};
+    },
+    getModels: function(query, options) {
+      var _ref;
+      if ((_ref = this.collection) != null ? _ref.query : void 0) {
+        query || (query = this.getQuery());
+        options || (options = this.getQueryOptions());
+        return this.collection.query(query, options);
+      } else {
+        return this.collection.models;
+      }
+    },
+    locateItemElement: function(id) {
+      return this.$("." + this.itemClassName + "[data-model-id='" + id + "']");
+    },
+    refreshModel: function(model) {
+      var index;
+      index = this.collection.indexOf(model);
+      return this.locateItemElement(model.get('id')).empty().append(this.contentForItem({
+        model: model,
+        index: index
+      }, model));
+    },
+    refresh: function(query, options) {
+      var index, model, models, _i, _len;
+      this.$bodyEl().empty();
+      models = this.getModels(query, options);
+      this.trigger("before:refresh", models, query, options);
+      if (models.length === 0) this.trigger("empty:results");
+      index = 0;
+      for (_i = 0, _len = models.length; _i < _len; _i++) {
+        model = models[_i];
+        this.$append(this.makeItem(model, index++));
+      }
+      this.trigger("after:refresh", models, query, options);
+      return this;
+    },
+    registerEvent: function(domEvent, selector, handler) {
+      var eventTrigger;
+      if (!(handler != null) && _.isFunction(selector)) {
+        handler = selector;
+        selector = void 0;
+      }
+      eventTrigger = _([domEvent, "" + this.itemTagName + "." + this.itemClassName, selector]).compact().join(" ");
+      return Luca.View.prototype.registerEvent(eventTrigger, handler);
+    },
+    render: function() {
+      this.refresh();
+      if (this.$el.parent().length > 0 && (this.container != null)) this.$attach();
+      return this;
+    }
+  });
+
+  make = Luca.View.prototype.make;
+
+  setupChangeObserver = function() {
+    var _this = this;
+    return this.collection.on("change", function(model) {
+      return _this.refreshModel(model);
+    });
+  };
+
+}).call(this);
+(function() {
+
+  _.def('Luca.components.Controller')["extends"]('Luca.containers.CardView')["with"]({
+    additionalClassNames: ['luca-ui-controller'],
+    activeAttribute: "active-section",
+    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]);
+      });
+    },
+    activeSection: function() {
+      return this.get("activeSection");
+    },
+    controllers: function(deep) {
+      if (deep == null) deep = false;
+      return this.select('ctype', 'controller', deep);
+    },
+    availableSections: function() {
+      var base,
+        _this = this;
+      base = {};
+      base[this.name] = this.sectionNames();
+      return _(this.controllers()).reduce(function(memo, controller) {
+        memo[controller.name] = controller.sectionNames();
+        return memo;
+      }, base);
+    },
+    sectionNames: function(deep) {
+      if (deep == null) deep = false;
+      return this.pluck('name');
+    },
+    "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);
+(function() {
+
+  _.def('Luca.fields.ButtonField')["extends"]('Luca.core.Field')["with"]({
+    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-/)) {
+        this.icon_class = "icon-" + this.icon_class;
+      }
+      if (this.white) return this.icon_class += " icon-white";
+    },
+    setValue: function() {
+      return true;
+    }
+  });
+
+}).call(this);
+(function() {
+  var make;
+
+  make = Luca.View.prototype.make;
+
+  _.def('Luca.fields.CheckboxArray')["extends"]('Luca.core.Field')["with"]({
+    version: 2,
+    template: "fields/checkbox_array",
+    className: "luca-ui-checkbox-array",
+    events: {
+      "click input": "clickHandler"
+    },
+    selectedItems: [],
+    initialize: function(options) {
+      this.options = options != null ? options : {};
+      _.extend(this, this.options);
+      _.extend(this, Luca.modules.Deferrable);
+      _.bindAll(this, "renderCheckboxes", "clickHandler", "checkSelected");
+      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.valueField || (this.valueField = "id");
+      return this.displayField || (this.displayField = "name");
+    },
+    afterInitialize: function(options) {
+      var cbArray;
+      this.options = options != null ? options : {};
+      try {
+        this.configure_collection();
+      } catch (e) {
+        console.log("Error Configuring Collection", this, e.message);
+      }
+      cbArray = this;
+      if (this.collection.length > 0) {
+        return this.renderCheckboxes();
+      } else {
+        return this.defer("renderCheckboxes").until(this.collection, "reset");
+      }
+    },
+    clickHandler: function(event) {
+      var checkbox;
+      checkbox = $(event.target);
+      if (checkbox.prop('checked')) {
+        return this.selectedItems.push(checkbox.val());
+      } else {
+        if (_(this.selectedItems).include(checkbox.val())) {
+          return this.selectedItems = _(this.selectedItems).without(checkbox.val());
+        }
+      }
+    },
+    controls: function() {
+      return this.$('.controls');
+    },
+    renderCheckboxes: function() {
+      var _this = this;
+      this.controls().empty();
+      this.selectedItems = [];
+      this.collection.each(function(model) {
+        var element, inputElement, input_id, label, value;
+        value = model.get(_this.valueField);
+        label = model.get(_this.displayField);
+        input_id = _.uniqueId("" + _this.cid + "_checkbox");
+        inputElement = make("input", {
+          type: "checkbox",
+          "class": "array-checkbox",
+          name: _this.input_name,
+          value: value,
+          id: input_id
+        });
+        element = make("label", {
+          "for": input_id
+        }, inputElement);
+        $(element).append(" " + label);
+        return _this.controls().append(element);
+      });
+      this.trigger("checkboxes:rendered", this.checkboxesRendered = true);
+      return this;
+    },
+    uncheckAll: function() {
+      return this.allFields().prop('checked', false);
+    },
+    allFields: function() {
+      return this.controls().find("input[type='checkbox']");
+    },
+    checkSelected: function(items) {
+      var checkbox, value, _i, _len, _ref;
+      if (items != null) this.selectedItems = items;
+      this.uncheckAll();
+      _ref = this.selectedItems;
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        value = _ref[_i];
+        checkbox = this.controls().find("input[value='" + value + "']");
+        checkbox.prop('checked', true);
+      }
+      return this.selectedItems;
+    },
+    getValue: function() {
+      var field, _i, _len, _ref, _results;
+      _ref = this.allFields();
+      _results = [];
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        field = _ref[_i];
+        if (this.$(field).prop('checked')) _results.push(this.$(field).val());
+      }
+      return _results;
+    },
+    setValue: function(items) {
+      var cbArray;
+      this.selectedItems = items;
+      if (this.checkboxesRendered === true) {
+        return this.checkSelected(items);
+      } else {
+        cbArray = this;
+        return this.defer(function() {
+          return cbArray.checkSelected(items);
+        }).until("checkboxes:rendered");
+      }
+    },
+    getValues: function() {
+      return this.getValue();
+    },
+    setValues: function(items) {
+      return this.setValue(items);
+    }
+  });
+
+}).call(this);
+(function() {
+
+  _.def('Luca.fields.CheckboxField')["extends"]('Luca.core.Field')["with"]({
+    events: {
+      "change input": "change_handler"
+    },
+    className: 'luca-ui-checkbox-field luca-ui-field',
+    template: 'fields/checkbox_field',
+    hooks: ["checked", "unchecked"],
+    send_blanks: true,
+    change_handler: function(e) {
+      var me, my;
+      me = my = $(e.target);
+      if (me.is(":checked")) {
+        this.trigger("checked");
+      } else {
+        this.trigger("unchecked");
+      }
+      return this.trigger("on:change", this, e, me.is(":checked"));
+    },
+    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.is(":checked");
+    }
+  });
+
+}).call(this);
+(function() {
+
+  _.def('Luca.fields.FileUploadField')["extends"]('Luca.core.Field')["with"]({
+    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 = "");
+    }
+  });
+
+}).call(this);
+(function() {
+
+  _.def('Luca.fields.HiddenField')["extends"]('Luca.core.Field')["with"]({
+    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);
+    }
+  });
+
+}).call(this);
+(function() {
+
+  _.def("Luca.components.LabelField")["extends"]("Luca.core.Field")["with"]({
+    className: "luca-ui-field luca-ui-label-field",
+    getValue: function() {
+      return this.$('input').attr('value');
+    },
+    formatter: function(value) {
+      value || (value = this.getValue());
+      return _.str.titleize(value);
+    },
+    setValue: function(value) {
+      this.trigger("change", value, this.getValue());
+      this.$('input').attr('value', value);
+      return this.$('.value').html(this.formatter(value));
+    }
+  });
+
+}).call(this);
+(function() {
+
+  _.def('Luca.fields.SelectField')["extends"]('Luca.core.Field')["with"]({
+    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] || record[0];
+        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);
+    }
+  });
+
+}).call(this);
+(function() {
+
+  _.def('Luca.fields.TextAreaField')["extends"]('Luca.core.Field')["with"]({
+    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"]);
+      this.input_value || (this.input_value = "");
+      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);
+    }
+  });
+
+}).call(this);
+(function() {
+
+  _.def('Luca.fields.TextField')["extends"]('Luca.core.Field')["with"]({
+    events: {
+      "blur input": "blur_handler",
+      "focus input": "focus_handler",
+      "change input": "change_handler"
+    },
+    template: 'fields/text_field',
+    autoBindEventHandlers: true,
+    send_blanks: true,
+    keyEventThrottle: 300,
+    initialize: function(options) {
+      this.options = options != null ? options : {};
+      if (this.enableKeyEvents) this.registerEvent("keyup input", "keyup_handler");
+      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"]);
+      this.input_value || (this.input_value = this.value || "");
+      if (this.prepend) {
+        this.$el.addClass('input-prepend');
+        this.addOn = this.prepend;
+      }
+      if (this.append) {
+        this.$el.addClass('input-append');
+        this.addOn = this.append;
+      }
+      return Luca.core.Field.prototype.initialize.apply(this, arguments);
+    },
+    keyup_handler: function(e) {
+      return this.trigger("on:keyup", this, e);
+    },
+    blur_handler: function(e) {
+      return this.trigger("on:blur", this, e);
+    },
+    focus_handler: function(e) {
+      return this.trigger("on:focus", this, e);
+    },
+    change_handler: function(e) {
+      return this.trigger("on:change", this, e);
+    }
+  });
+
+}).call(this);
+(function() {
+
+  _.def('Luca.fields.TypeAheadField')["extends"]('Luca.fields.TextField')["with"]({
+    className: 'luca-ui-field',
+    getSource: function() {
+      if (_.isFunction(this.source)) return this.source.call(this);
+      return this.source || [];
+    },
+    matcher: function(item) {
+      return true;
+    },
+    beforeRender: function() {
+      this._super("beforeRender", this, arguments);
+      return this.$('input').attr('data-provide', 'typeahead');
+    },
+    afterRender: function() {
+      this._super("afterRender", this, arguments);
+      return this.$('input').typeahead({
+        matcher: this.matcher,
+        source: this.getSource()
+      });
+    }
+  });
+
+}).call(this);
+(function() {
+
+  _.def('Luca.components.FormButtonToolbar')["extends"]('Luca.components.Toolbar')["with"]({
+    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'
+        });
+      }
+    }
+  });
+
+}).call(this);
+(function() {
+  var defaultToolbar;
+
+  defaultToolbar = {
+    buttons: [
+      {
+        icon: "remove-sign",
+        label: "Reset",
+        eventId: "click:reset",
+        className: "reset-button",
+        align: 'right'
+      }, {
+        icon: "ok-sign",
+        white: true,
+        label: "Save Changes",
+        eventId: "click:submit",
+        color: "success",
+        className: 'submit-button',
+        align: 'right'
+      }
+    ]
+  };
+
+  _.def("Luca.components.FormView")["extends"]('Luca.core.Container')["with"]({
+    tagName: 'form',
+    className: 'luca-ui-form-view',
+    hooks: ["before:submit", "before:reset", "before:load", "before:load:new", "before:load:existing", "after:submit", "after:reset", "after:load", "after:load:new", "after:load:existing", "after:submit:success", "after:submit:fatal_error", "after:submit:error"],
+    events: {
+      "click .submit-button": "submitHandler",
+      "click .reset-button": "resetHandler"
+    },
+    toolbar: true,
+    legend: "",
+    bodyClassName: "form-view-body",
+    version: "0.9.33333333",
+    initialize: function(options) {
+      this.options = options != null ? options : {};
+      if (this.loadMask == null) this.loadMask = Luca.enableBootstrap;
+      Luca.core.Container.prototype.initialize.apply(this, arguments);
+      this.components || (this.components = this.fields);
+      _.bindAll(this, "submitHandler", "resetHandler", "renderToolbars", "applyLoadMask");
+      this.state || (this.state = new Backbone.Model);
+      this.setupHooks(this.hooks);
+      this.applyStyleClasses();
+      if (this.toolbar !== false && (!this.topToolbar && !this.bottomToolbar)) {
+        if (this.toolbar === "both" || this.toolbar === "top") {
+          this.topToolbar = this.getDefaultToolbar();
+        }
+        if (this.toolbar !== "top") {
+          return this.bottomToolbar = this.getDefaultToolbar();
+        }
+      }
+    },
+    getDefaultToolbar: function() {
+      return defaultToolbar;
+    },
+    applyStyleClasses: function() {
+      if (Luca.enableBootstrap) this.applyBootstrapStyleClasses();
+      if (this.labelAlign) this.$el.addClass("label-align-" + this.labelAlign);
+      if (this.fieldLayoutClass) return this.$el.addClass(this.fieldLayoutClass);
+    },
+    applyBootstrapStyleClasses: function() {
+      if (this.labelAlign === "left") this.inlineForm = true;
+      if (this.well) this.$el.addClass('well');
+      if (this.searchForm) this.$el.addClass('form-search');
+      if (this.horizontalForm) this.$el.addClass('form-horizontal');
+      if (this.inlineForm) return this.$el.addClass('form-inline');
+    },
+    resetHandler: function(e) {
+      var me, my;
+      me = my = $(e != null ? e.target : void 0);
+      this.trigger("before:reset", this);
+      this.reset();
+      return this.trigger("after:reset", this);
+    },
+    submitHandler: function(e) {
+      var me, my;
+      me = my = $(e != null ? e.target : void 0);
+      this.trigger("before:submit", this);
+      if (this.loadMask === true) this.trigger("enable:loadmask", this);
+      if (this.hasModel()) return this.submit();
+    },
+    afterComponents: function() {
+      var _ref,
+        _this = this;
+      if ((_ref = Luca.core.Container.prototype.afterComponents) != null) {
+        _ref.apply(this, arguments);
+      }
+      return this.eachField(function(field) {
+        field.getForm = function() {
+          return _this;
+        };
+        return field.getModel = function() {
+          return _this.currentModel();
+        };
+      });
+    },
+    eachField: function(iterator) {
+      return _(this.getFields()).map(iterator);
+    },
+    getField: function(name) {
+      var passOne;
+      passOne = _(this.getFields('name', name)).first();
+      if (passOne != null) return passOne;
+      return _(this.getFields('input_name', name)).first();
+    },
+    getFields: function(attr, value) {
+      var fields;
+      fields = this.selectByAttribute("isField", true, true);
+      if ((attr != null) && (value != null)) {
+        fields = _(fields).select(function(field) {
+          var property;
+          property = field[attr];
+          if (_.isFunction(property)) property = property.call(field);
+          return property === value;
+        });
+      }
+      return fields;
+    },
+    loadModel: function(current_model) {
+      var event, fields, form, _ref;
+      this.current_model = current_model;
+      form = this;
+      fields = this.getFields();
+      this.trigger("before:load", this, this.current_model);
+      if (this.current_model) {
+        if ((_ref = this.current_model.beforeFormLoad) != null) {
+          _ref.apply(this.current_model, this);
+        }
+        event = "before:load:" + (this.current_model.isNew() ? "new" : "existing");
+        this.trigger(event, this, this.current_model);
+      }
+      this.setValues(this.current_model);
+      this.trigger("after:load", this, this.current_model);
+      if (this.current_model) {
+        return this.trigger("after:load:" + (this.current_model.isNew() ? "new" : "existing"), this, this.current_model);
+      }
+    },
+    reset: function() {
+      if (this.current_model != null) return this.loadModel(this.current_model);
+    },
+    clear: function() {
+      var _this = this;
+      this.current_model = this.defaultModel != null ? this.defaultModel() : void 0;
+      return _(this.getFields()).each(function(field) {
+        try {
+          return field.setValue('');
+        } catch (e) {
+          return console.log("Error Clearing", _this, field);
+        }
+      });
+    },
+    setValues: function(source, options) {
+      var fields,
+        _this = this;
+      if (options == null) options = {};
+      source || (source = this.currentModel());
+      fields = this.getFields();
+      _(fields).each(function(field) {
+        var field_name, value;
+        field_name = field.input_name || field.name;
+        if (value = source[field_name]) {
+          if (_.isFunction(value)) value = value.apply(_this);
+        }
+        if (!value && Luca.isBackboneModel(source)) value = source.get(field_name);
+        if (field.readOnly !== true) {
+          return field != null ? field.setValue(value) : void 0;
+        }
+      });
+      if ((options.silent != null) !== true) return this.syncFormWithModel();
+    },
+    getValues: function(options) {
+      var values,
+        _this = this;
+      if (options == null) options = {};
+      if (options.reject_blank == null) options.reject_blank = true;
+      if (options.skip_buttons == null) options.skip_buttons = true;
+      if (options.blanks === false) options.reject_blank = true;
+      values = _(this.getFields()).inject(function(memo, field) {
+        var allowBlankValues, key, skip, value, valueIsBlank;
+        value = field.getValue();
+        key = field.input_name || field.name;
+        valueIsBlank = !!(_.str.isBlank(value) || _.isUndefined(value));
+        allowBlankValues = !options.reject_blank && !field.send_blanks;
+        if (options.debug) {
+          console.log("" + key + " Options", options, "Value", value, "Value Is Blank?", valueIsBlank, "Allow Blanks?", allowBlankValues);
+        }
+        if (options.skip_buttons && field.ctype === "button_field") {
+          skip = true;
+        } else {
+          if (valueIsBlank && allowBlankValues === false) skip = true;
+          if (field.input_name === "id" && valueIsBlank === true) skip = true;
+        }
+        if (options.debug) console.log("Skip is true on " + key);
+        if (skip !== true) memo[key] = value;
+        return memo;
+      }, options.defaults || {});
+      return values;
+    },
+    submit_success_handler: function(model, response, xhr) {
+      this.trigger("after:submit", this, model, response);
+      if (this.loadMask === true) this.trigger("disable:loadmask", this);
+      if (response && (response != null ? response.success : void 0) === true) {
+        return this.trigger("after:submit:success", this, model, response);
+      } else {
+        return this.trigger("after:submit:error", this, model, response);
+      }
+    },
+    submit_fatal_error_handler: function(model, response, xhr) {
+      this.trigger("after:submit", this, model, response);
+      return this.trigger("after:submit:fatal_error", this, model, response);
+    },
+    submit: function(save, saveOptions) {
+      if (save == null) save = true;
+      if (saveOptions == null) saveOptions = {};
+      _.bindAll(this, "submit_success_handler", "submit_fatal_error_handler");
+      saveOptions.success || (saveOptions.success = this.submit_success_handler);
+      saveOptions.error || (saveOptions.error = this.submit_fatal_error_handler);
+      this.syncFormWithModel();
+      if (!save) return;
+      return this.current_model.save(this.current_model.toJSON(), saveOptions);
+    },
+    hasModel: function() {
+      return this.current_model != null;
+    },
+    currentModel: function(options) {
+      if (options == null) options = {};
+      if (options === true || (options != null ? options.refresh : void 0) === true) {
+        this.syncFormWithModel();
+      }
+      return this.current_model;
+    },
+    syncFormWithModel: function() {
+      var _ref;
+      return (_ref = this.current_model) != null ? _ref.set(this.getValues()) : void 0;
+    },
+    setLegend: function(legend) {
+      this.legend = legend;
+      return $('fieldset legend', this.el).first().html(this.legend);
+    },
+    flash: function(message) {
+      if (this.$('.toolbar-container.top').length > 0) {
+        return this.$('.toolbar-container.top').after(message);
+      } else {
+        return this.$bodyEl().prepend(message);
+      }
+    },
+    successFlashDelay: 1500,
+    successMessage: function(message) {
+      var _this = this;
+      this.$('.alert.alert-success').remove();
+      this.flash(Luca.template("components/form_alert", {
+        className: "alert alert-success",
+        message: message
+      }));
+      return _.delay(function() {
+        return _this.$('.alert.alert-success').fadeOut();
+      }, this.successFlashDelay || 0);
+    },
+    errorMessage: function(message) {
+      this.$('.alert.alert-error').remove();
+      return this.flash(Luca.template("components/form_alert", {
+        className: "alert alert-error",
+        message: message
+      }));
+    }
+  });
+
+}).call(this);
+(function() {
+
+  _.def('Luca.components.GridView').extend('Luca.components.Panel')["with"]({
+    bodyTemplate: "components/grid_view",
+    autoBindEventHandlers: true,
+    events: {
+      "dblclick table tbody tr": "double_click_handler",
+      "click table tbody tr": "click_handler"
+    },
+    className: 'luca-ui-g-view',
+    rowClass: "luca-ui-g-row",
+    wrapperClass: "luca-ui-g-view-wrapper",
+    additionalWrapperClasses: [],
+    wrapperStyles: {},
+    scrollable: true,
+    emptyText: 'No Results To display.',
+    tableStyle: 'striped',
+    defaultHeight: 285,
+    defaultWidth: 756,
+    maxWidth: void 0,
+    hooks: ["before:grid:render", "before:render:header", "before:render:row", "after:grid:render", "row:double:click", "row:click", "after:collection:load"],
+    initialize: function(options) {
+      var _this = this;
+      this.options = options != null ? options : {};
+      _.extend(this, this.options);
+      _.extend(this, Luca.modules.Deferrable);
+      if (this.loadMask == null) this.loadMask = Luca.enableBootstrap;
+      if (this.loadMask === true) {
+        this.loadMaskEl || (this.loadMaskEl = ".luca-ui-g-view-body");
+      }
+      Luca.components.Panel.prototype.initialize.apply(this, arguments);
+      this.configure_collection(true);
+      this.collection.bind("before:fetch", function() {
+        if (_this.loadMask === true) return _this.trigger("enable:loadmask");
+      });
+      this.collection.bind("reset", function(collection) {
+        _this.refresh();
+        if (_this.loadMask === true) _this.trigger("disable:loadmask");
+        return _this.trigger("after:collection:load", collection);
+      });
+      return this.collection.bind("change", function(model) {
+        var cells, rowEl;
+        if (_this.rendered !== true) return;
+        try {
+          rowEl = _this.getRowEl(model.id || model.get('id') || model.cid);
+          cells = _this.render_row(model, _this.collection.indexOf(model), {
+            cellsOnly: true
+          });
+          return $(rowEl).html(cells.join(" "));
+        } catch (error) {
+          return console.log("Error in change handler for GridView.collection", error, _this, model);
+        }
+      });
+    },
+    beforeRender: function() {
+      var _ref;
+      if ((_ref = Luca.components.Panel.prototype.beforeRender) != null) {
+        _ref.apply(this, arguments);
+      }
+      this.trigger("before:grid:render", this);
+      this.table = this.$('table.luca-ui-g-view');
+      this.header = this.$("thead");
+      this.body = this.$("tbody");
+      this.footer = this.$("tfoot");
+      this.wrapper = this.$("." + this.wrapperClass);
+      this.applyCssClasses();
+      if (this.scrollable) this.setDimensions();
+      this.renderHeader();
+      this.emptyMessage();
+      return $(this.container).append(this.$el);
+    },
+    afterRender: function() {
+      var _ref;
+      if ((_ref = Luca.components.Panel.prototype.afterRender) != null) {
+        _ref.apply(this, arguments);
+      }
+      this.rendered = true;
+      this.refresh();
+      return this.trigger("after:grid:render", this);
+    },
+    applyCssClasses: function() {
+      var _ref,
+        _this = this;
+      if (this.scrollable) this.$el.addClass('scrollable-g-view');
+      _(this.additionalWrapperClasses).each(function(containerClass) {
+        var _ref;
+        return (_ref = _this.wrapper) != null ? _ref.addClass(containerClass) : void 0;
+      });
+      if (Luca.enableBootstrap) this.table.addClass('table');
+      return _((_ref = this.tableStyle) != null ? _ref.split(" ") : void 0).each(function(style) {
+        return _this.table.addClass("table-" + style);
+      });
+    },
+    setDimensions: function(offset) {
+      var _this = this;
+      this.height || (this.height = this.defaultHeight);
+      this.$('.luca-ui-g-view-body').height(this.height);
+      this.$('tbody.scrollable').height(this.height - 23);
+      this.container_width = (function() {
+        return $(_this.container).width();
+      })();
+      this.width || (this.width = this.container_width > 0 ? this.container_width : this.defaultWidth);
+      this.width = _([this.width, this.maxWidth || this.width]).max();
+      this.$('.luca-ui-g-view-body').width(this.width);
+      this.$('.luca-ui-g-view-body table').width(this.width);
+      return this.setDefaultColumnWidths();
+    },
+    resize: function(newWidth) {
+      var difference, distribution,
+        _this = this;
+      difference = newWidth - this.width;
+      this.width = newWidth;
+      this.$('.luca-ui-g-view-body').width(this.width);
+      this.$('.luca-ui-g-view-body table').width(this.width);
+      if (this.columns.length > 0) {
+        distribution = difference / this.columns.length;
+        return _(this.columns).each(function(col, index) {
+          var column;
+          column = $(".column-" + index, _this.el);
+          return column.width(col.width = col.width + distribution);
+        });
+      }
+    },
+    padLastColumn: function() {
+      var configured_column_widths, unused_width;
+      configured_column_widths = _(this.columns).inject(function(sum, column) {
+        return sum = column.width + sum;
+      }, 0);
+      unused_width = this.width - configured_column_widths;
+      if (unused_width > 0) return this.lastColumn().width += unused_width;
+    },
+    setDefaultColumnWidths: function() {
+      var default_column_width;
+      default_column_width = this.columns.length > 0 ? this.width / this.columns.length : 200;
+      _(this.columns).each(function(column) {
+        return parseInt(column.width || (column.width = default_column_width));
+      });
+      return this.padLastColumn();
+    },
+    lastColumn: function() {
+      return this.columns[this.columns.length - 1];
+    },
+    emptyMessage: function(text) {
+      if (text == null) text = "";
+      text || (text = this.emptyText);
+      this.body.html('');
+      return this.body.append(Luca.templates["components/grid_view_empty_text"]({
+        colspan: this.columns.length,
+        text: text
+      }));
+    },
+    refresh: function() {
+      var _this = this;
+      this.body.html('');
+      this.collection.each(function(model, index) {
+        return _this.render_row.apply(_this, [model, index]);
+      });
+      if (this.collection.models.length === 0) return this.emptyMessage();
+    },
+    ifLoaded: function(fn, scope) {
+      scope || (scope = this);
+      fn || (fn = function() {
+        return true;
+      });
+      return this.collection.ifLoaded(fn, scope);
+    },
+    applyFilter: function(values, options) {
+      if (options == null) {
+        options = {
+          auto: true,
+          refresh: true
+        };
+      }
+      return this.collection.applyFilter(values, options);
+    },
+    renderHeader: function() {
+      var headers,
+        _this = this;
+      this.trigger("before:render:header");
+      headers = _(this.columns).map(function(column, column_index) {
+        var style;
+        style = column.width ? "width:" + column.width + "px;" : "";
+        return "<th style='" + style + "' class='column-" + column_index + "'>" + column.header + "</th>";
+      });
+      return this.header.append("<tr>" + headers + "</tr>");
+    },
+    getRowEl: function(id) {
+      return this.$("[data-record-id=" + id + "]", 'table');
+    },
+    render_row: function(row, row_index, options) {
+      var altClass, cells, content, model_id, rowClass, _ref,
+        _this = this;
+      if (options == null) options = {};
+      rowClass = this.rowClass;
+      model_id = (row != null ? row.get : void 0) && (row != null ? row.attributes : void 0) ? row.get('id') : '';
+      this.trigger("before:render:row", row, row_index);
+      cells = _(this.columns).map(function(column, col_index) {
+        var display, style, value;
+        value = _this.cell_renderer(row, column, col_index);
+        style = column.width ? "width:" + column.width + "px;" : "";
+        display = _.isUndefined(value) ? "" : value;
+        return "<td style='" + style + "' class='column-" + col_index + "'>" + display + "</td>";
+      });
+      if (options.cellsOnly) return cells;
+      altClass = '';
+      if (this.alternateRowClasses) {
+        altClass = row_index % 2 === 0 ? "even" : "odd";
+      }
+      content = "<tr data-record-id='" + model_id + "' data-row-index='" + row_index + "' class='" + rowClass + " " + altClass + "' id='row-" + row_index + "'>" + cells + "</tr>";
+      if (options.contentOnly === true) return content;
+      return (_ref = this.body) != null ? _ref.append(content) : void 0;
+    },
+    cell_renderer: function(row, column, columnIndex) {
+      var source;
+      if (_.isFunction(column.renderer)) {
+        return column.renderer.apply(this, [row, column, columnIndex]);
+      } else if (column.data.match(/\w+\.\w+/)) {
+        source = row.attributes || row;
+        return Luca.util.nestedValue(column.data, source);
+      } else {
+        return (typeof row.get === "function" ? row.get(column.data) : void 0) || row[column.data];
+      }
+    },
+    double_click_handler: function(e) {
+      var me, my, record, rowIndex;
+      me = my = $(e.currentTarget);
+      rowIndex = my.data('row-index');
+      record = this.collection.at(rowIndex);
+      return this.trigger("row:double:click", this, record, rowIndex);
+    },
+    click_handler: function(e) {
+      var me, my, record, rowIndex;
+      me = my = $(e.currentTarget);
+      rowIndex = my.data('row-index');
+      record = this.collection.at(rowIndex);
+      this.trigger("row:click", this, record, rowIndex);
+      $("." + this.rowClass, this.body).removeClass('selected-row');
+      return me.addClass('selected-row');
+    }
+  });
+
+}).call(this);
+(function() {
+
+  _.def("Luca.components.LoadMask")["extends"]("Luca.View")["with"]({
+    className: "luca-ui-load-mask",
+    bodyTemplate: "components/load_mask"
+  });
+
+}).call(this);
+(function() {
+
+  _.def("Luca.components.NavBar")["extends"]("Luca.View")["with"]({
+    fixed: true,
+    position: 'top',
+    className: 'navbar',
+    brand: "Luca.js",
+    bodyTemplate: 'nav_bar',
+    bodyClassName: 'luca-ui-navbar-body',
+    beforeRender: function() {
+      if (this.fixed) this.$el.addClass("navbar-fixed-" + this.position);
+      if (this.brand != null) {
+        this.content().append("<a class='brand' href='#'>" + this.brand + "</a>");
+      }
+      if (this.template) {
+        return this.content().append(Luca.template(this.template, this));
+      }
+    },
+    render: function() {
+      return this;
+    },
+    content: function() {
+      return this.$('.container').eq(0);
+    }
+  });
+
+}).call(this);
+(function() {
+
+  _.def("Luca.PageController")["extends"]("Luca.components.Controller")["with"]({
+    version: 2
+  });
+
+}).call(this);
+(function() {
+  var paginationControl;
+
+  paginationControl = Luca.define("Luca.components.PaginationControl");
+
+  paginationControl["extends"]("Luca.View");
+
+  paginationControl.defaultsTo({
+    template: "components/pagination",
+    stateful: true,
+    autoBindEventHandlers: true,
+    events: {
+      "click a[data-page-number]": "selectPage",
+      "click a.next": "nextPage",
+      "click a.prev": "previousPage"
+    },
+    afterInitialize: function() {
+      return this.state.on("change", this.refresh, this);
+    },
+    limit: function() {
+      var _ref;
+      return parseInt(this.state.get('limit') || ((_ref = this.collection) != null ? _ref.length : void 0));
+    },
+    page: function() {
+      return parseInt(this.state.get('page') || 1);
+    },
+    nextPage: function() {
+      if (!this.nextEnabled()) return;
+      return this.state.set('page', this.page() + 1);
+    },
+    previousPage: function() {
+      if (!this.previousEnabled()) return;
+      return this.state.set('page', this.page() - 1);
+    },
+    selectPage: function(e) {
+      var me, my;
+      me = my = this.$(e.target);
+      if (!me.is('a.page')) me = my = my.closest('a.page');
+      my.siblings().removeClass('is-selected');
+      me.addClass('is-selected');
+      return this.setPage(my.data('page-number'));
+    },
+    setPage: function(page, options) {
+      if (page == null) page = 1;
+      if (options == null) options = {};
+      return this.state.set('page', page, options);
+    },
+    setLimit: function(limit, options) {
+      if (limit == null) limit = 1;
+      if (options == null) options = {};
+      return this.state.set('limit', limit, options);
+    },
+    pageButtonContainer: function() {
+      return this.$('.group');
+    },
+    previousEnabled: function() {
+      return this.page() > 1;
+    },
+    nextEnabled: function() {
+      return this.page() < this.totalPages();
+    },
+    previousButton: function() {
+      return this.$('a.page.prev');
+    },
+    nextButton: function() {
+      return this.$('a.page.next');
+    },
+    pageButtons: function() {
+      return this.$('a[data-page-number]', this.pageButtonContainer());
+    },
+    refresh: function() {
+      var button, page, _ref;
+      this.pageButtonContainer().empty();
+      for (page = 1, _ref = this.totalPages(); 1 <= _ref ? page <= _ref : page >= _ref; 1 <= _ref ? page++ : page--) {
+        button = this.make("a", {
+          "data-page-number": page,
+          "class": "page"
+        }, page);
+        this.pageButtonContainer().append(button);
+      }
+      this.toggleNavigationButtons();
+      return this.selectActivePageButton();
+    },
+    toggleNavigationButtons: function() {
+      this.$('a.next, a.prev').addClass('disabled');
+      if (this.nextEnabled()) this.nextButton().removeClass('disabled');
+      if (this.previousEnabled()) {
+        return this.previousButton().removeClass('disabled');
+      }
+    },
+    selectActivePageButton: function() {
+      return this.activePageButton().addClass('is-selected');
+    },
+    activePageButton: function() {
+      return this.pageButtons().filter("[data-page-number='" + (this.page()) + "']");
+    },
+    totalPages: function() {
+      return parseInt(Math.ceil(this.totalItems() / this.itemsPerPage()));
+    },
+    totalItems: function() {
+      var _ref;
+      return parseInt(((_ref = this.collection) != null ? _ref.length : void 0) || 0);
+    },
+    itemsPerPage: function(value, options) {
+      if (options == null) options = {};
+      if (value != null) this.set("limit", value, options);
+      return parseInt(this.get("limit"));
+    }
+  });
+
+}).call(this);
+(function() {
+
+  _.def('Luca.components.RecordManager')["extends"]('Luca.containers.CardView')["with"]({
+    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);
+(function() {
+
+  _.def("Luca.Router")["extends"]("Backbone.Router")["with"]({
+    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);
+(function() {
+  var make;
+
+  _.def("Luca.components.TableView")["extends"]("Luca.components.CollectionView")["with"]({
+    additionalClassNames: "table",
+    tagName: "table",
+    bodyTemplate: "table_view",
+    bodyTagName: "tbody",
+    bodyClassName: "table-body",
+    itemTagName: "tr",
+    stateful: true,
+    observeChanges: true,
+    columns: [],
+    emptyText: "There are no results to display",
+    itemRenderer: function(item, model) {
+      return Luca.components.TableView.rowRenderer.call(this, item, model);
+    },
+    initialize: function(options) {
+      var column,
+        _this = this;
+      this.options = options != null ? options : {};
+      Luca.components.CollectionView.prototype.initialize.apply(this, arguments);
+      this.columns = (function() {
+        var _i, _len, _ref, _results;
+        _ref = this.columns;
+        _results = [];
+        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+          column = _ref[_i];
+          if (_.isString(column)) {
+            column = {
+              reader: column
+            };
+          }
+          if (!(column.header != null)) {
+            column.header = _.str.titleize(_.str.humanize(column.reader));
+          }
+          _results.push(column);
+        }
+        return _results;
+      }).call(this);
+      return this.defer(function() {
+        return Luca.components.TableView.renderHeader.call(_this, _this.columns, _this.$('thead'));
+      }).until("after:render");
+    }
+  });
+
+  make = Backbone.View.prototype.make;
+
+  Luca.components.TableView.renderHeader = function(columns, targetElement) {
+    var column, content, index, _i, _len, _results;
+    index = 0;
+    content = (function() {
+      var _i, _len, _results;
+      _results = [];
+      for (_i = 0, _len = columns.length; _i < _len; _i++) {
+        column = columns[_i];
+        _results.push("<th data-col-index='" + (index++) + "'>" + column.header + "</th>");
+      }
+      return _results;
+    })();
+    console.log("one");
+    this.$(targetElement).append(make("tr", {}, content));
+    console.log("two");
+    index = 0;
+    console.log("three");
+    _results = [];
+    for (_i = 0, _len = columns.length; _i < _len; _i++) {
+      column = columns[_i];
+      if (column.width != null) {
+        _results.push(this.$("th[data-col-index='" + (index++) + "']", targetElement).css('width', column.width));
+      }
+    }
+    return _results;
+  };
+
+  Luca.components.TableView.rowRenderer = function(item, model, index) {
+    var colIndex, columnConfig, _i, _len, _ref, _results;
+    colIndex = 0;
+    _ref = this.columns;
+    _results = [];
+    for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+      columnConfig = _ref[_i];
+      _results.push(Luca.components.TableView.renderColumn.call(this, columnConfig, item, model, colIndex++));
+    }
+    return _results;
+  };
+
+  Luca.components.TableView.renderColumn = function(column, item, model, index) {
+    var cellValue;
+    cellValue = model.read(column.reader);
+    if (_.isFunction(column.renderer)) {
+      cellValue = column.renderer.call(this, cellValue, model, column);
+    }
+    return make("td", {
+      "data-col-index": index
+    }, cellValue);
+  };
+
+}).call(this);
+(function() {
+
+  _.def("Luca.components.ToolbarDialog")["extends"]("Luca.View")["with"]({
+    className: "luca-ui-toolbar-dialog span well",
+    styles: {
+      "position": "absolute",
+      "z-Index": "3000",
+      "float": "left"
+    },
+    initialize: function(options) {
+      this.options = options != null ? options : {};
+      return this._super("initialize", this, arguments);
+    },
+    createWrapper: function() {
+      return this.make("div", {
+        "class": "component-picker span4 well",
+        style: "position: absolute; z-index:12000"
+      });
+    },
+    show: function() {
+      return this.$el.parent().show();
+    },
+    hide: function() {
+      return this.$el.parent().hide();
+    },
+    toggle: function() {
+      return this.$el.parent().toggle();
+    }
+  });
+
+}).call(this);
+(function() {
+
+
+
+}).call(this);
+(function() {
+
+
+
+}).call(this);
+
+
+
 (function() {