luca 0.9.9 → 0.9.42

data/src/core/field.coffee

@@ -0,0 +1,79 @@
+_.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"
+  ]
+
+  # see: http://twitter.github.com/bootstrap/base-css.html
+  statuses: [
+    "warning"
+    "error"
+    "success"
+  ]
+
+  initialize: (@options={})->
+    _.extend @, @options
+
+    @input_id ||= _.uniqueId('field')
+    @input_name ||= @name
+    @input_class ||= ""
+    @helperText ||= ""
+    @label ||= "*#{ @label }" if @required and not @label?.match(/^\*/)
+    @inputStyles ||= ""
+
+    @disable() if @disabled
+
+    @updateState( @state )
+    @placeHolder ||= ""
+
+    Luca.View::initialize.apply(@, arguments)
+
+  beforeRender: ()->
+    if Luca.enableBootstrap
+      @$el.addClass('control-group')
+
+    @$el.addClass('required') if @required
+
+    @$el.html Luca.template(@template, @)
+    @input = $('input', @el)
+
+  change_handler: (e)->
+    @trigger "on:change", @, e
+
+  disable: ()->
+    $("input",@el).attr('disabled', true)
+
+  enable: ()->
+    $("input", @el).attr('disabled', false)
+
+  getValue: ()->
+    raw = @input.attr('value')
+
+    return raw if _.str.isBlank( raw )
+
+    switch @valueType
+      when "integer" then parseInt(raw)
+      when "string" then "#{ raw }"
+      when "float" then parseFloat(raw)
+      else raw
+
+  render: ()->
+    $( @container ).append( @$el )
+
+  setValue: (value)->
+    @input.attr('value', value)
+
+  updateState: (state)->
+    _( @statuses ).each (cls)=>
+      @$el.removeClass(cls)
+      @$el.addClass(state)

data/src/core/model.coffee

@@ -0,0 +1,43 @@
+# Computed Properties Support
+# ###
+#
+# Luca.Model supports computed properties, which are 
+# object methods which are composed of model attributes or
+# of calculations which are dependent on these attributes.
+
+# When these model attributes change, the computed property
+# needs to be re-evaluated.  
+#
+# The configuration API for computed properties expects a hash
+# whose keys are the name of the method, and whose value is
+# an array of the attribute dependencies for that method.  
+setupComputedProperties = ()->
+  return if _.isUndefined(@computed)
+
+  @_computed = {}
+
+  for attr, dependencies of @computed
+    @on "change:#{attr}", ()=>
+      @_computed[attr] = @[attr].call @
+
+    dependencies = dependencies.split(',') if _.isString(dependencies)
+
+    _(dependencies).each (dep)=>
+      @on "change:#{dep}", ()=>
+        @trigger "change:#{attr}"
+        
+      @trigger "change:#{attr}" if @has(dep) 
+
+_.def('Luca.Model').extends('Backbone.Model').with
+
+  include: ['Luca.Events']
+
+  initialize: ()->
+    Backbone.Model::initialize(@, arguments)
+    setupComputedProperties.call(@)
+
+  get: (attr)->
+    if @computed?.hasOwnProperty(attr)
+      @_computed[attr]
+    else
+      Backbone.Model::get.call @, attr

data/src/core/panel.coffee

@@ -0,0 +1,118 @@
+# This is a helper for creating the DOM element that go along with
+# a given component, if it is configured to use one via the topToolbar
+# and bottomToolbar properties
+attachToolbar = (config={}, targetEl)->
+  config.orientation ||= "top"
+  config.ctype ||= @toolbarType || "panel_toolbar"
+
+  id = "#{ @cid }-tbc-#{ config.orientation }"
+
+  toolbar = Luca.util.lazyComponent( config )
+
+  container = @make "div",
+    class:"toolbar-container #{ config.orientation }",
+    id: id
+  ,
+    toolbar.render().el
+
+  hasBody = @bodyClassName or @bodyTagName
+
+  # there will be a body panel inside of the views $el
+  # so just place the toolbar before, or after the body
+  action = switch config.orientation
+    when "top", "left"
+      if hasBody then "before" else "prepend"
+    when "bottom", "right"
+      if hasBody then "after" else "append"
+
+  (targetEl || @$bodyEl() )[action]( container )
+
+# A Panel is a basic Luca.View but with Toolbar extensions
+#
+# In general other components should inherit from the panel class.
+
+_.def("Luca.components.Panel").extends("Luca.View").with
+
+  topToolbar: undefined
+
+  bottomToolbar: undefined
+
+  # Load Mask will apply a transparent overlay over the form
+  # upon submission, with a moving progress bar which will be
+  # hidden upon successful response
+  loadMask: false
+  loadMaskTemplate: ["components/load_mask"]
+  loadMaskTimeout: 3000
+  
+  mixins:["LoadMaskable"]
+
+  initialize: (@options={})->
+    Luca.View::initialize.apply(@, arguments)
+    
+
+  applyStyles: (styles={},body=false)->
+
+    target = if body then @$bodyEl() else @$el
+
+    for setting, value  of styles
+      target.css(setting,value)
+
+    @
+
+  beforeRender: ()->
+    Luca.View::beforeRender?.apply(@, arguments)
+    @applyStyles( @styles ) if @styles?
+    @applyStyles( @bodyStyles, true ) if @bodyStyles?
+    @renderToolbars?()
+
+  $bodyEl: ()->
+    element = @bodyTagName || "div"
+    className = @bodyClassName || "view-body"
+
+    @bodyEl ||= "#{ element }.#{ className }"
+
+    bodyEl = @$(@bodyEl)
+
+    return bodyEl if bodyEl.length > 0
+
+    # if we've been configured to have one, and it doesn't exist
+    # then we should append it to ourselves
+    if bodyEl.length is 0 and (@bodyClassName? || @bodyTagName?)
+      newElement = @make(element,class:className,"data-auto-appended":true)
+      $(@el).append( newElement )
+      return @$(@bodyEl)
+
+
+    $(@el)
+
+  $wrap: (wrapper)->
+    if _.isString(wrapper) and not wrapper.match(/[<>]/)
+      wrapper = @make("div",class:wrapper)
+
+    @$el.wrap( wrapper )
+
+  $template: (template, variables={})->
+    @$html( Luca.template(template,variables) )
+
+  $empty: ()->
+    @$bodyEl().empty()
+    
+  $html: (content)->
+    @$bodyEl().html( content )
+
+  $append: (content)->
+    @$bodyEl().append(content)
+
+  # Luca containers can have toolbars,
+  # these will get injected before or after the bodyEl, or at the top
+  # or bottom of the $el
+  renderToolbars: ()->
+    _( ["top","left","right","bottom"] ).each (orientation)=>
+      if config = @["#{ orientation }Toolbar"]
+        @renderToolbar( orientation, config)
+
+  renderToolbar: (orientation="top", config={})->
+    config.parent = @
+    config.orientation = orientation
+
+    attachToolbar.call(@, config, config.targetEl )

data/{app/assets/javascripts/luca/core/registry → src/core}/registry.coffee

@@ -4,57 +4,51 @@ registry =
   collection_classes: {}
   namespaces:['Luca.containers','Luca.components']
 
-componentCacheStore =
+component_cache =
   cid_index: {}
   name_index: {}
 
 # For container views, if a component is defined with no ctype
 # then we will pick this one when using
-Luca.config.defaultComponentClass = Luca.defaultComponentClass  = 'Luca.View'
-Luca.config.defaultComponentType  = Luca.defaultComponentType   = 'view'
-
-Luca.registry.deprecatedComponents = {}
-Luca.registry.componentAliases = {}
-
-Luca.registry.typeAliases = 
-  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.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"
 
 # When you use _.def to define a component, you say
 # which class it extends() from, and with() which enhancements.
 # We register that component class for you:
-Luca.registerComponent = (component, prototypeName, componentType="view")->
+Luca.register = (component, prototypeName, componentType="view")->
   Luca.trigger "component:registered", component, prototypeName
 
   switch componentType
     when "model"
-      existing = registry.model_classes[ component ]
       registry.model_classes[ component ] = prototypeName
     when "collection"
-      existing = registry.collection_classes[ component ]
       registry.collection_classes[ component ] = prototypeName
-    when "view"
-      existing = registry.classes[ component ]
-      registry.classes[ component ] = prototypeName
     else
-      existing = registry.classes[ component ]
       registry.classes[ component ] = prototypeName
 
-  if existing? and Luca.config.developmentMode is true 
+Luca.development_mode_register = (component, prototypeName)->
+  existing = registry.classes[component]
+
+  if Luca.enableDevelopmentTools is true and existing?
+    prototypeDefinition = Luca.util.resolve( existing, window)
+
     liveInstances = Luca.registry.findInstancesByClassName( prototypeName )
-    if liveInstances.length > 0
-      existingInstance.refreshEventBindings?() for existingInstance in liveInstances
 
+    _( liveInstances ).each (instance)->
+      instance?.refreshCode?.call(instance, prototypeDefinition)
+
+  Luca.register( component, prototypeName )
 
 # We create a @ctype alias for this component definition, and register
 # the class in a registry.
@@ -62,7 +56,7 @@ Luca.registerComponent = (component, prototypeName, componentType="view")->
 # If you use a custom namespace like MyApp.views.ListView,
 # then we will register MyApp.views as a namespace.  You can
 # do this yourself too.
-Luca.registry.addNamespace = Luca.registry.namespace = (identifier)->
+Luca.registry.addNamespace = (identifier)->
   registry.namespaces.push( identifier )
   registry.namespaces = _( registry.namespaces ).uniq()
 
@@ -77,11 +71,13 @@ Luca.registry.namespaces = (resolve=true)->
   _( registry.namespaces ).map (namespace)->
     if resolve then Luca.util.resolve( namespace ) else namespace
 
+
+
 # Lookup a component in the Luca component registry
-# by it's type identifier.  If it doesn't exist,
+# by it's ctype identifier.  If it doesn't exist,
 # check any other registered namespace
 Luca.registry.lookup = (ctype)->
-  if alias = Luca.registry.typeAliases[ ctype ] 
+  if alias = Luca.registry.aliases[ ctype ] 
     ctype = alias
     
   c = registry.classes[ctype]
@@ -97,17 +93,11 @@ Luca.registry.lookup = (ctype)->
   .compact().value()?[0]
 
 Luca.registry.instances = ()->
-  _( componentCacheStore.cid_index ).values()
- 
-Luca.registry.findInstancesByClass = (componentClass)->
-  Luca.registry.findInstancesByClassName( componentClass.displayName )
-
+  _( component_cache.cid_index ).values()
+  
 Luca.registry.findInstancesByClassName = (className)->
-  className = className.displayName if not _.isString( className )
   instances = Luca.registry.instances() 
   _( instances ).select (instance)->
-    isClass = instance.displayName is className
-
     instance.displayName is className or instance._superClass?()?.displayName is className
 
 Luca.registry.classes = (toString=false)->
@@ -118,32 +108,22 @@ Luca.registry.classes = (toString=false)->
       className: className
       ctype: ctype
 
-Luca.registry.find = (search)->
-  Luca.util.resolve(search) || Luca.define.findDefinition(search)
-
-Luca.remove = Luca.registry.removeInstance = (cacheKey)->
-  return unless cacheKey?
-  _( componentCacheStore.name_index ).delete( cacheKey )
-  _( componentCacheStore.cid_index ).delete( cacheKey )
+Luca.cache = (needle, component)->
+  component_cache.cid_index[ needle ] = component if component?
 
-Luca.cache = Luca.registry.cacheInstance = (cacheKey, object)->
-  return unless cacheKey?
-  return object if object?.doNotCache is true
+  component = component_cache.cid_index[ needle ]
 
-  if object?
-    componentCacheStore.cid_index[ cacheKey ] = object 
+  # optionally, cache it by tying its name to its cid for easier lookups
+  if component?.component_name?
+    component_cache.name_index[ component.component_name ] = component.cid
+  else if component?.name?
+    component_cache.name_index[ component.name ] = component.cid
 
-  object = componentCacheStore.cid_index[ cacheKey ]
+  return component if component?
 
-  # optionally, cache it by tying its name to its cid for easier lookups
-  if object?.component_name?
-    componentCacheStore.name_index[ object.component_name ] = object.cid
-  else if object?.name?
-    componentCacheStore.name_index[ object.name ] = object.cid
+  # perform a lookup by name if the component_id didn't turn anything
+  lookup_id = component_cache.name_index[ needle ]
 
-  return object if object?
+  component_cache.cid_index[ lookup_id ]
 
-  # perform a lookup by name if the cid lookup didn't turn anything
-  lookup_id = componentCacheStore.name_index[ cacheKey ]
 
-  componentCacheStore.cid_index[ lookup_id ]

data/src/core/view.coffee

@@ -0,0 +1,264 @@
+_.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: (@options={})->
+    @trigger "before:initialize", @, @options
+
+    _.extend @, @options
+
+    bindAllEventHandlers.call(@) if @autoBindEventHandlers is true or @bindAllEvents is true
+
+    setupBodyTemplate.call(@)
+
+    @cid = _.uniqueId(@name) if @name?
+
+
+
+    Luca.cache( @cid, @ )
+
+    @setupHooks _( Luca.View::hooks.concat( @hooks ) ).uniq()
+
+
+    if @additionalClassNames
+      @additionalClassNames = @additionalClassNames.split(" ") if _.isString(@additionalClassNames)
+
+    if @gridSpan
+      @additionalClassNames.push "span#{ @gridSpan }"
+
+    if @gridOffset
+      @additionalClassNames.push "offset#{ @gridOffset }"
+
+    if @gridRowFluid
+      @additionalClassNames.push "row-fluid"
+
+    if @gridRow
+      @additionalClassNames.push "row"
+
+    if @additionalClassNames?.length > 0
+      @$el.addClass( additional ) for additional in @additionalClassNames
+
+    @$wrap( @wrapperClass ) if @wrapperClass?
+
+    registerCollectionEvents.call(@)
+    registerApplicationEvents.call( @)
+
+    @delegateEvents()
+
+    if @stateful is true and not @state?
+      @state = new Backbone.Model(@defaultState || {})
+      unless @set?
+        @set = ()=> @state.set.apply(@state, argumuments)
+
+      unless @get?
+        @get = ()=> @state.get.apply(@state, argumuments)
+
+    if @mixins?.length > 0
+      for module in @mixins
+        Luca.modules[ module ]._included.call(@, @, module)
+
+    @trigger "after:initialize", @
+
+  $wrap: (wrapper)->
+    if _.isString(wrapper) and not wrapper.match(/[<>]/)
+      wrapper = @make("div",class:wrapper)
+
+    @$el.wrap( wrapper )
+
+  $template: (template, variables={})->
+    @$el.html( Luca.template(template,variables) )
+
+  $html: (content)->
+    @$el.html( content )
+
+  $append: (content)->
+    @$el.append( content )
+
+  $attach: ()->
+    @$container().append( @el )
+
+  $bodyEl: ()->
+    @$el
+    
+  $container: ()->
+    $(@container)
+
+  #### Hooks or Auto Event Binding
+  #
+  # views which inherit from Luca.View can define hooks
+  # or events which can be emitted from them.  Automatically,
+  # any functions on the view which are named according to the
+  # convention will automatically get run.
+  #
+  # by default, all Luca.View classes come with the following:
+  #
+  # before:render     : beforeRender()
+  # after:render      : afterRender()
+  # after:initialize  : afterInitialize()
+  # first:activation  : firstActivation()
+  setupHooks: (set)->
+    set ||= @hooks
+
+    _(set).each (eventId)=>
+      fn = Luca.util.hook( eventId )
+
+      callback = ()=>
+        @[fn]?.apply @, arguments
+
+      callback = _.once(callback) if eventId?.match(/once:/)
+
+      @bind eventId, callback
+
+  registerEvent: (selector, handler)->
+    @events ||= {}
+    @events[ selector ] = handler
+    @delegateEvents()
+
+  definitionClass: ()->
+    Luca.util.resolve(@displayName, window)?.prototype
+
+  collections: ()-> Luca.util.selectProperties( Luca.isBackboneCollection, @ )
+  models: ()-> Luca.util.selectProperties( Luca.isBackboneModel, @ )
+  views: ()-> Luca.util.selectProperties( Luca.isBackboneView, @ )
+
+  debug: ()->
+    return unless @debugMode or window.LucaDebugMode?
+    console.log [(@name || @cid),message] for message in arguments
+
+  trigger: ()->
+    if Luca.enableGlobalObserver
+      if Luca.developmentMode is true or @observeEvents is true
+        Luca.ViewObserver ||= new Luca.Observer(type:"view")
+        Luca.ViewObserver.relay @, arguments
+
+    Backbone.View.prototype.trigger.apply @, arguments
+
+
+originalExtend = Backbone.View.extend
+
+customizeRender = (definition)->
+  _base = definition.render
+
+  _base ||= Luca.View::$attach
+
+  definition.render = ()->
+    view = @
+    # if a view has a deferrable property set
+
+    if @deferrable
+      target = @deferrable_target
+
+      unless Luca.isBackboneCollection(@deferrable)
+        @deferrable = @collection
+
+      target ||= @deferrable
+      trigger = if @deferrable_event then @deferrable_event else "reset"
+
+      deferred = ()->
+        _base.call(view)
+        view.trigger("after:render", view)
+
+      view.defer(deferred).until(target, trigger)
+
+      view.trigger "before:render", @
+
+      autoTrigger = @deferrable_trigger || @deferUntil
+
+      if !autoTrigger?
+        target[ (@deferrable_method||"fetch") ].call(target)
+      else
+        fn = _.once ()=> @deferrable[ (@deferrable_method||"fetch") ]?()
+        (@deferrable_target || @ ).bind(@deferrable_trigger, fn)
+
+      return @
+
+    else
+      @trigger "before:render", @
+      _base.apply(@, arguments)
+      @trigger "after:render", @
+
+      return @
+
+  definition
+
+bindAllEventHandlers = ()->
+  _( @events ).each (handler,event)=>
+    if _.isString(handler)
+      _.bindAll @, handler
+
+registerApplicationEvents = ()->
+  return if _.isEmpty(@applicationEvents)
+
+  app = @app
+
+  if _.isString( app ) or _.isUndefined( app )
+    app = Luca.Application?.get?(app)
+
+  unless Luca.supportsEvents( app )
+    throw "Error binding to the application object on #{ @name || @cid }"
+
+  for eventTrigger, handler in @applicationEvents
+    handler = @[handler] if _.isString(handler) 
+
+    unless _.isFunction(handler)
+      throw "Error registering application event #{ eventTrigger } on #{ @name || @cid }"
+
+    app.on(eventTrigger, handler)
+
+registerCollectionEvents = ()->
+  return if _.isEmpty( @collectionEvents )
+
+  manager = @collectionManager
+
+  if _.isString( manager ) or _.isUndefined( manager )
+    manager = Luca.CollectionManager.get( manager )
+
+  for signature, handler of @collectionEvents
+    console.log "Sig", signature, "Handler", handler
+    [key,eventTrigger] = signature.split(" ")
+
+    collection = manager.getOrCreate( key )
+
+    if !collection
+      throw "Could not find collection specified by #{ key }"
+
+    if _.isString(handler)
+      handler = @[handler]
+
+    unless _.isFunction(handler)
+      throw "invalid collectionEvents configuration"
+
+    try
+      collection.bind(eventTrigger, handler)
+    catch e
+      console.log "Error Binding To Collection in registerCollectionEvents", @
+      throw e
+
+setupBodyTemplate = ()->
+  templateVars = if @bodyTemplateVars
+    @bodyTemplateVars.call(@)
+  else
+    @
+
+  if template = @bodyTemplate
+    @$el.empty()
+    Luca.View::$html.call(@, Luca.template(template, templateVars ) )
+      
+Luca.View.extend = (definition)->
+  definition = customizeRender( definition )
+
+  if definition.mixins? and _.isArray( definition.mixins )
+    _.extend(definition, Luca.modules[module]) for module in definition.mixins
+
+  originalExtend.call(@, definition)