luca 0.9.42 → 0.9.65

data/src/core/container.coffee

@@ -1,90 +1,53 @@
-# The Component Container
-#
-# The Component Container is a nestable component
-# which are responsible for handling communication between multiple
-# nested views.
-#
-# One: Layout
-#
-# a container is responsible for laying out the nested views
-# and rendering them in a special DOM element
-doLayout = ()->
-  @trigger "before:layout", @
-  @prepareLayout()
-  @trigger "after:layout", @
-
-# and displaying those elements in a way that is
-# optimal for the desired user experience of that view
-# ( i.e seeing only one of them at a time, seeing them side by side )
-applyDOMConfig = (panel, panelIndex)->
-  style_declarations = []
-
-  style_declarations.push "height: #{ (if _.isNumber(panel.height) then panel.height + 'px' else panel.height ) }" if panel.height?
-  style_declarations.push "width: #{ (if _.isNumber(panel.width) then panel.width + 'px' else panel.width ) }" if panel.width?
-  style_declarations.push "float: #{ panel.float }" if panel.float
-
-  config =
-    class: panel?.classes || @componentClass
-    id: "#{ @cid }-#{ panelIndex }"
-    style: style_declarations.join(';')
-    "data-luca-owner" : @name || @cid
-
-  if @customizeContainerEl?
-   config = @customizeContainerEl( config, panel, panelIndex )
-
-  config
+container = Luca.register         "Luca.core.Container"
 
-# Two: Component Creation
-#
-# A container is responsible for creating and storing references to the nested
-# views that are required for its functioning.
-doComponents = ()->
+container.extends                 "Luca.components.Panel"
 
-  @trigger "before:components", @, @components
-  @prepareComponents()
-  @createComponents()
-  @trigger "before:render:components", @, @components
-  @renderComponents()
-  @trigger "after:components", @, @components
-
-
-# Containers are central to Luca.  They are what make it easy to structure
-# your application in a logical way and to specify much of the behavior of
-# complex / composite views at define time using JSON syntax combined with
-# the meta data contained in the Luca component registry.
-_.def('Luca.core.Container').extends('Luca.components.Panel').with
+container.triggers                "before:components",
+                                  "before:render:components",
+                                  "before:layout",
+                                  "after:components",
+                                  "after:layout",
+                                  "first:activation"
 
+container.defines
   className: 'luca-ui-container'
 
   componentTag: 'div'
+
   componentClass: 'luca-ui-panel'
 
   isContainer: true
 
-  hooks:[
-    "before:components"
-    "before:render:components"
-    "before:layout"
-    "after:components"
-    "after:layout"
-    "first:activation"
-  ]
-
   rendered: false
 
   components: []
 
+  # @componentEvents provides declarative syntax for responding to events on
+  # the components in this container.  the format of the syntax is very similar
+  # to the other event binding helpers:
+  #
+  #   component_accessor component:trigger
+  #
+  # where component_accessor is either the name of the role, or a method on the container
+  # which will find the component in question.
+  #
+  # myContainer = new Luca.core.Container
+  #   componentEvents:
+  #     "name component:trigger"    : "handler"
+  #     "role component:trigger"    : "handler"
+  #     "getter component:trigger"  : "handler"
+  #
+  componentEvents: {}
+
   initialize: (@options={})->
     _.extend @, @options
 
-    @setupHooks [
-      "before:components"
-      "before:render:components"
-      "before:layout"
-      "after:components"
-      "after:layout"
-      "first:activation"
-    ]
+    @setupHooks( Luca.core.Container::hooks )
+
+    # aliases for the components property
+    @components ||= @fields ||= @pages ||= @cards ||= @views
+
+    validateContainerConfiguration(@)
 
     Luca.View::initialize.apply @, arguments
 
@@ -183,6 +146,9 @@ _.def('Luca.core.Container').extends('Luca.components.Panel').with
     map = @componentIndex =
       name_index: {}
       cid_index: {}
+      role_index: {}
+
+    container   = @
 
     @components = _( @components ).map (object, index)=>
 
@@ -191,43 +157,42 @@ _.def('Luca.core.Container').extends('Luca.components.Panel').with
       # adding the views @$el to the appropriate @container.
 
       # you can also just pass a string representing the component_type
-      component = if Luca.isBackboneView( object )
+      component = if Luca.isComponent( object )
         object
       else
         object.type ||= object.ctype
 
         if !object.type?
+          # TODO
+          # Add support for all of the various components property aliases
           if object.components?
             object.type = object.ctype = 'container'
           else
             object.type = object.ctype = Luca.defaultComponentType
 
-        Luca.util.lazyComponent( object )
+        # if the container defines a @defaults property
+        # then we should make sure our child components inherit
+        # these values unless specifically defined
+        object = _.defaults(object, (container.defaults || {}))
 
-      # if you define a @getter property as a string on your component
-      # we will create a function with that name on this container that
-      # allows you to access this component
-      if _.isString( component.getter )
-        @[ component.getter ] = (()-> component) 
+        created = Luca.util.lazyComponent( object )
 
       # if we're using base backbone views, then they don't extend themselves
       # with their passed options, so this is a workaround to get them to
       # pick up the container config property
-      if !component.container and component.options.container
+      if !component.container and component.options?.container
         component.container = component.options.container
 
-      if map and component.cid?
-        map.cid_index[ component.cid ] = index
+      if not component.container?
+        console.log component,index,@
+        console.error "could not assign container property to component on container #{ @name || @cid }"
 
-      if map and component.name?
-        map.name_index[ component.name ] = index
+      indexComponent( component ).at(index).in( @componentIndex )
 
       component
 
     @componentsCreated = true
 
-    @registerComponentEvents() unless _.isEmpty(@componentEvents)
-
     map
 
   # Trigger the Rendering Pipeline process on all of the nested
@@ -235,14 +200,14 @@ _.def('Luca.core.Container').extends('Luca.components.Panel').with
   renderComponents: (@debugMode="")->
     @debug "container render components"
 
-    container = @ 
+    container = @
     _(@components).each (component)->
-      component.getParent = ()-> 
-        container 
+      component.getParent = ()->
+        container
 
       try
-        $( component.container ).append( component.el )
-        component.render() 
+        @$( component.container ).eq(0).append( component.el )
+        component.render()
       catch e
         console.log "Error Rendering Component #{ component.name || component.cid }", component
 
@@ -271,32 +236,74 @@ _.def('Luca.core.Container').extends('Luca.components.Panel').with
         component.previously_activated = true
 
   #### Underscore Methods For Working with Components
-  pluck: (attribute)-> 
-    _( @components ).pluck attribute
+  _: ()-> _( @components )
+
+  pluck: (attribute)->
+    @_().pluck(attribute)
 
   invoke: (method)->
-    _( @components ).invoke method
+    @_().invoke(method)
+
+  select: (fn)->
+    @_().select(fn)
+
+  detect: (fn)->
+    @_().detect(attribute)
+
+  reject: (fn)->
+    @_().reject(fn)
 
   map: (fn)->
-    _( @components ).map(fn)
-    
-  # event binding sugar for nested components
-  #
-  # you can define events like:
+    @_().map(fn)
 
-  # _.def("MyContainer").extends("Luca.View").with
-  #   componentEvents:
-  #     "component_name before:load" : "mySpecialHandler"
-  componentEvents: {}
+  registerComponentEvents: (eventList)->
+    container = @
+
+    for listener, handler of (eventList || @componentEvents||{})
+      [componentNameOrRole,eventId] = listener.split(' ')
+
+      unless _.isFunction( @[handler] )
+        console.log "Error registering component event", listener, componentNameOrRole, eventId
+        throw "Invalid component event definition #{ listener }. Specified handler is not a method on the container"
+
+      if componentNameOrRole is "*"
+        @eachComponent (component)=> component.on(eventId, @[handler], container)
+      else
+        component = @findComponentForEventBinding( componentNameOrRole )
+
+        unless component? and Luca.isComponent(component)
+          console.log "Error registering component event", listener, componentNameOrRole, eventId
+          throw "Invalid component event definition: #{ componentNameOrRole }"
 
-  registerComponentEvents: ()->
-    for listener, handler of @componentEvents
-      [componentName,trigger] = listener.split(' ')
-      component = @findComponentByName(componentName)
-      component?.bind trigger, @[handler]
+        component?.bind eventId, @[handler], container
+
+
+  subContainers: ()->
+    @select (component)->
+      component.isContainer is true
+
+  roles: ()->
+    _( @allChildren() ).pluck('role')
+
+  allChildren: ()->
+    children = @components
+    grandchildren = _( @subContainers() ).invoke('allChildren')
+    _([children,grandchildren]).chain().compact().flatten().value()
+
+  findComponentForEventBinding: (nameRoleOrGetter, deep=true)->
+    @findComponentByName(nameRoleOrGetter, deep) || @findComponentByGetter( nameRoleOrGetter, deep ) || @findComponentByRole( nameRoleOrGetter, deep )
+
+  findComponentByGetter: (getter, deep=false)->
+    _( @allChildren() ).detect (component)->
+      component.getter is getter
+
+  findComponentByRole: (role,deep=false)->
+    _( @allChildren() ).detect (component)->
+      component.role is role or component.type is role or component.ctype is role
 
   findComponentByName: (name, deep=false)->
-    @findComponent(name, "name_index", deep)
+    _( @allChildren() ).detect (component)->
+      component.name is name
 
   findComponentById: (id, deep=false)->
     @findComponent(id, "cid_index", deep)
@@ -305,12 +312,14 @@ _.def('Luca.core.Container').extends('Luca.components.Panel').with
     @createComponents() unless @componentsCreated is true
 
     position = @componentIndex?[ haystack ][ needle ]
-    component = @components?[ position ]
+    component = @components[ position ]
 
     return component if component
 
     if deep is true
-      sub_container = _( @components ).detect (component)-> component?.findComponent?(needle, haystack, true)
+      sub_container = _( @components ).detect (component)->
+        component?.findComponent?(needle, haystack, true)
+
       sub_container?.findComponent?(needle, haystack, true)
 
   each: (fn)->
@@ -333,27 +342,24 @@ _.def('Luca.core.Container').extends('Luca.components.Panel').with
     return @components[ @activeItem ]
 
   componentElements: ()->
-    @$(">.#{ @componentClass }", @$bodyEl())
+    @$("[data-luca-parent='#{ @name || @cid }']")
 
   getComponent: (needle)->
     @components[ needle ]
 
-  rootComponent: ()->
-    console.log "Calling rootComponent will be deprecated.  use isRootComponent instead"
-    !@getParent?
-
   isRootComponent:()->
     !@getParent?
 
   getRootComponent: ()->
-    if @rootComponent() then @ else @getParent().getRootComponent()
-    
-  selectByAttribute: (attribute, value, deep=false)->
+    if @isRootComponent() then @ else @getParent().getRootComponent()
+
+
+  selectByAttribute: (attribute, value=undefined, deep=false)->
     components = _( @components ).map (component)->
       matches = []
       test = component[ attribute ]
 
-      matches.push( component ) if test is value
+      matches.push( component ) if test is value or (not value? and test?)
 
       # recursively traverse our components
       matches.push component.selectByAttribute?(attribute, value, true) if deep is true
@@ -362,13 +368,91 @@ _.def('Luca.core.Container').extends('Luca.components.Panel').with
 
     _.flatten( components )
 
-  select: (attribute, value, deep=false)->
-    console.log "Container.select will be replaced by selectByAttribute in 1.0"
-    Luca.core.Container::selectByAttribute.apply(@, arguments)
 
 # This is the method by which a container injects the rendered child views
 # into the DOM.  It will get passed the container object, and the component
-# that is being rendered.  
+# that is being rendered.
 Luca.core.Container.componentRenderer = (container, component)->
   attachMethod = $( component.container )[ component.attachWith || "append" ]
   attachMethod( component.render().el )
+
+
+#### Private Helpers
+
+doLayout = ()->
+  @trigger "before:layout", @
+  @prepareLayout()
+  @trigger "after:layout", @
+
+applyDOMConfig = (panel, panelIndex)->
+  style_declarations = []
+
+  style_declarations.push "height: #{ (if _.isNumber(panel.height) then panel.height + 'px' else panel.height ) }" if panel.height?
+  style_declarations.push "width: #{ (if _.isNumber(panel.width) then panel.width + 'px' else panel.width ) }" if panel.width?
+  style_declarations.push "float: #{ panel.float }" if panel.float
+
+  config =
+    class: panel?.classes || @componentClass
+    id: "#{ @cid }-#{ panelIndex }"
+    style: style_declarations.join(';')
+    "data-luca-parent" : @name || @cid
+
+  if @customizeContainerEl?
+   config = @customizeContainerEl( config, panel, panelIndex )
+
+  config
+
+
+
+createGetterMethods = ()->
+  container = @
+
+  childrenWithGetter = _( @allChildren() ).select (component)->
+    component.getter?
+
+  _( childrenWithGetter ).each (component)->
+    container[ component.getter ] ||= ()->
+      console.log component.getter, component, container
+      component
+
+createMethodsToGetComponentsByRole = ()->
+  container = @
+
+  childrenWithRole = _( @allChildren() ).select (component)->
+    component.role?
+
+  _( childrenWithRole ).each (component)->
+    getter = _.str.camelize( "get_" + component.role )
+    container[ getter ] ||= ()->
+      component
+
+doComponents = ()->
+  @trigger "before:components", @, @components
+  @prepareComponents()
+  @createComponents()
+  @trigger "before:render:components", @, @components
+  @renderComponents()
+  @trigger "after:components", @, @components
+
+  unless @skipGetterMethods is true
+    createGetterMethods.call(@)
+    createMethodsToGetComponentsByRole.call(@)
+
+  @registerComponentEvents()
+
+validateContainerConfiguration = ()->
+  true
+
+
+# Private Helpers
+#
+# indexComponent( component ).at( index ).in( componentsInternalIndexMap )
+indexComponent = (component)->
+  at: (index)->
+    in: (map)->
+      if component.cid?
+        map.cid_index[ component.cid ] = index
+      if component.role?
+        map.role_index[ component.role ] = index
+      if component.name?
+        map.name_index[ component.name ] = index

data/src/core/field.coffee

@@ -27,15 +27,21 @@ _.def('Luca.core.Field').extends('Luca.View').with
     @input_id ||= _.uniqueId('field')
     @input_name ||= @name
     @input_class ||= ""
+    @input_type ||= ""
     @helperText ||= ""
     @label ||= "*#{ @label }" if @required and not @label?.match(/^\*/)
     @inputStyles ||= ""
+    @input_value ||= @value || ""
 
     @disable() if @disabled
 
     @updateState( @state )
     @placeHolder ||= ""
 
+    # In order to support using Luca.View template properties everywhere.
+
+    # Will need to work around how the field classes
+    # apply templates to themselves.
     Luca.View::initialize.apply(@, arguments)
 
   beforeRender: ()->
@@ -44,20 +50,17 @@ _.def('Luca.core.Field').extends('Luca.View').with
 
     @$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)
+    @getInputElement().attr('disabled', true)
 
   enable: ()->
-    $("input", @el).attr('disabled', false)
+    @getInputElement().attr('disabled', false)
 
   getValue: ()->
-    raw = @input.attr('value')
+    raw = @getInputElement()?.attr('value')
 
     return raw if _.str.isBlank( raw )
 
@@ -67,11 +70,11 @@ _.def('Luca.core.Field').extends('Luca.View').with
       when "float" then parseFloat(raw)
       else raw
 
-  render: ()->
-    $( @container ).append( @$el )
-
   setValue: (value)->
-    @input.attr('value', value)
+    @getInputElement()?.attr('value', value)
+
+  getInputElement: ()->
+    @input ||= @$('input').eq(0)
 
   updateState: (state)->
     _( @statuses ).each (cls)=>

data/src/core/model.coffee

@@ -1,16 +1,26 @@
-# 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.  
+model = Luca.define       'Luca.Model'
+
+model.extends             'Backbone.Model'
+
+model.includes            'Luca.Events'
+
+model.defines
+  initialize: ()->
+    Backbone.Model::initialize(@, arguments)
+    setupComputedProperties.call(@)
+
+  read: (attr)->
+    if _.isFunction(@[attr])
+      @[attr].call(@)
+    else
+      @get(attr)
+
+  get: (attr)->
+    if @computed?.hasOwnProperty(attr)
+      @_computed[attr]
+    else
+      Backbone.Model::get.call @, attr
+
 setupComputedProperties = ()->
   return if _.isUndefined(@computed)
 
@@ -27,17 +37,3 @@ setupComputedProperties = ()->
         @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/registry.coffee

@@ -4,29 +4,34 @@ registry =
   collection_classes: {}
   namespaces:['Luca.containers','Luca.components']
 
-component_cache =
+componentCacheStore =
   cid_index: {}
   name_index: {}
 
 # For container views, if a component is defined with no ctype
 # then we will pick this one when using
-Luca.defaultComponentType = 'view'
+Luca.config.defaultComponentClass = Luca.defaultComponentClass  = 'Luca.View'
+Luca.config.defaultComponentType  = 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"
+  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"
+
 
 # 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.register = (component, prototypeName, componentType="view")->
+Luca.registerComponent = (component, prototypeName, componentType="view")->
   Luca.trigger "component:registered", component, prototypeName
 
   switch componentType
@@ -48,7 +53,7 @@ Luca.development_mode_register = (component, prototypeName)->
     _( liveInstances ).each (instance)->
       instance?.refreshCode?.call(instance, prototypeDefinition)
 
-  Luca.register( component, prototypeName )
+  Luca.registerComponent( component, prototypeName )
 
 # We create a @ctype alias for this component definition, and register
 # the class in a registry.
@@ -56,7 +61,7 @@ Luca.development_mode_register = (component, prototypeName)->
 # 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 = (identifier)->
+Luca.registry.addNamespace = Luca.registry.namespace = (identifier)->
   registry.namespaces.push( identifier )
   registry.namespaces = _( registry.namespaces ).uniq()
 
@@ -93,11 +98,17 @@ Luca.registry.lookup = (ctype)->
   .compact().value()?[0]
 
 Luca.registry.instances = ()->
-  _( component_cache.cid_index ).values()
-  
+  _( componentCacheStore.cid_index ).values()
+ 
+Luca.registry.findInstancesByClass = (componentClass)->
+  Luca.registry.findInstancesByClassName( componentClass.displayName )
+
 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)->
@@ -108,22 +119,24 @@ Luca.registry.classes = (toString=false)->
       className: className
       ctype: ctype
 
-Luca.cache = (needle, component)->
-  component_cache.cid_index[ needle ] = component if component?
+Luca.cache = Luca.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
-
-  return component if component?
+  object = componentCacheStore.cid_index[ cacheKey ]
 
-  # perform a lookup by name if the component_id didn't turn anything
-  lookup_id = component_cache.name_index[ needle ]
+  # 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
 
-  component_cache.cid_index[ lookup_id ]
+  return object if object?
 
+  # perform a lookup by name if the cid lookup didn't turn anything
+  lookup_id = componentCacheStore.name_index[ cacheKey ]
 
+  componentCacheStore.cid_index[ lookup_id ]