luca 0.9.76 → 0.9.89

data/app/assets/javascripts/luca/core/index.coffee

@@ -0,0 +1,12 @@
+#= require ./registry
+#= require ./observer
+#= require ./events
+#= require ./templates
+#= require_tree ../concerns
+#= require ./model
+#= require ./collection
+#= require ./view
+#= require ./panel
+#= require_self
+
+

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

@@ -29,7 +29,7 @@ setupComputedProperties = ()->
 
   for attr, dependencies of @computed
     @on "change:#{attr}", ()=>
-      @_computed[attr] = @[attr].call @
+      @_computed[attr] = @read(attr) 
 
     dependencies = dependencies.split(',') if _.isString(dependencies)
 

data/app/assets/javascripts/luca/core/panel.coffee

@@ -0,0 +1,124 @@
+# Luca.Panel is a low level Luca.View component which is used 
+# to build components which have toolbar areas, and a body area for the main
+# contents of the view.
+panel = Luca.register           "Luca.Panel"
+
+panel.replaces                  "Luca.Panel"
+
+panel.extends                   "Luca.View"
+
+panel.configuration
+  topToolbar: undefined
+  bottomToolbar: undefined
+  #loadMask: false
+  #loadMaskTemplate: "components/load_mask"
+  #loadMaskTimeout: 3000
+
+panel.publicMethods
+  applyStyles: (styles={},body=false)->
+
+    target = if body then @$bodyEl() else @$el
+
+    for setting, value  of styles
+      target.css(setting,value)
+
+    @
+
+  $bodyEl: ()->
+    element = @bodyTagName || "div"
+    className = @bodyClassName || "view-body"
+
+    @bodyEl ||= "#{ element }.#{ className }"
+
+    bodyEl = @$(@bodyEl)
+
+    return bodyEl if bodyEl.length > 0
+
+    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)
+
+panel.privateMethods
+  beforeRender: ()->
+    Luca.View::beforeRender?.apply(@, arguments)
+    @applyStyles( @styles ) if @styles?
+    @applyStyles( @bodyStyles, true ) if @bodyStyles?
+    @renderToolbars?()
+
+  renderToolbars: ()->
+    _( ["top","left","right","bottom"] ).each (orientation)=>
+      if config = @["#{ orientation }Toolbar"]
+        @renderToolbar( orientation, config)
+
+  renderToolbar: (orientation="top", config={})->
+    config.parent = @
+    config.orientation = orientation
+    el = Luca.util.read( config.container )
+    el ||= Luca.util.read( config.targetEl )
+
+    Luca.Panel.attachToolbar.call(@, config, el )
+
+panel.classMethods
+  attachToolbar: (config={}, targetEl)->
+    config.orientation ||= "top"
+    config.type ||= config.ctype ||= @toolbarType || "panel_toolbar"
+
+    config.additionalClassNames = "#{ Luca.config.toolbarContainerClass } #{ config.orientation }"
+  
+    toolbar = Luca.util.lazyComponent( config )
+    # TEMP
+    # Do this properly
+    if config.orientation is "bottom"
+      @getBottomToolbar ||= ()-> toolbar   
+
+    if config.orientation is "top"
+      @getTopToolbar ||= ()-> toolbar   
+
+    if config.orientation is "right"
+      @getRightToolbar ||= ()-> toolbar   
+
+    if config.orientation is "left"
+      @getLeftToolbar ||= ()-> toolbar   
+
+    hasBody = @bodyClassName or @bodyTagName
+
+    action = config.attachmentAction
+    # 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 and not targetEl?.length > 0 then "before" else "prepend"
+
+      when "bottom", "right"
+        if hasBody and not targetEl?.length > 0 then "after" else "append"
+
+    toolbarEl = if targetEl?.length > 0
+      @$(targetEl)
+    else
+      @$bodyEl()
+
+    toolbarEl[action]( toolbar.render().el )
+
+panel.defines
+  version: 3

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

@@ -73,15 +73,30 @@ class ComponentDefinition
   in: (@namespace)-> @
 
   # allow for multiple ways of saying the same thing for readability purposes
-  from: (@superClassName)-> @
-  extends: (@superClassName)-> @
-  extend: (@superClassName)-> @
+  from: (@superClassName)-> 
+    @
+  extends: (@superClassName)-> 
+    @
+  extend: (@superClassName)-> 
+    @
+
+  aliases: (@_aliases...)->
+    @meta("aliases", @_aliases)
+    @
+
+  replaces: (replaces...)->
+    @_aliases ||= []
+    for old in replaces
+      @_aliases.push(old)
+      Luca.util.deprecateComponent(old, @componentName)
 
   triggers: (hooks...)->
     _.defaults(@properties ||= {}, hooks: []) 
     for hook in hooks
       @properties.hooks.push(hook) 
+
     @properties.hooks = _.uniq(@properties.hooks)
+
     @meta("hooks", @properties.hooks)
     @
 
@@ -125,6 +140,11 @@ class ComponentDefinition
     _.defaults((@_classProperties||={}), properties)
     @
 
+  configuration: (properties={})->
+    @meta("public configuration", _.keys(properties) )
+    _.defaults((@properties||={}), properties)
+    @
+
   publicConfiguration: (properties={})->
     @meta("public configuration", _.keys(properties) )
     _.defaults((@properties||={}), properties)
@@ -140,11 +160,26 @@ class ComponentDefinition
     _.defaults((@_classProperties||={}), properties)
     @
 
+  methods: (properties={})->
+    @meta("public interface", _.keys(properties) )
+    _.defaults((@properties||={}), properties)
+    @
+
+  public: (properties={})->
+    @meta("public interface", _.keys(properties) )
+    _.defaults((@properties||={}), properties)
+    @
+
   publicInterface: (properties={})->
     @meta("public interface", _.keys(properties) )
     _.defaults((@properties||={}), properties)
     @
 
+  private: (properties={})->
+    @meta("private interface", _.keys(properties) )
+    _.defaults((@properties||={}), properties)
+    @
+
   privateInterface: (properties={})->
     @meta("private interface", _.keys(properties) )
     _.defaults((@properties||={}), properties)
@@ -177,6 +212,17 @@ class ComponentDefinition
 
     definition = at[@componentId] = Luca.extend(@superClassName,@componentName, @properties)
 
+    if _.isArray( @properties?.include )
+      for include in @properties.include
+        include = Luca.util.resolve(include) if _.isString(include)
+        if not include?
+          console.log "Attempt to include module failed. #{ include } not defined."
+        _.extend(definition::, include)
+
+    if @_aliases?
+      for alias in @_aliases
+        eval("#{ alias } = definition;")
+
     if @autoRegister is true 
       componentType = "view" if Luca.isViewPrototype( definition )
 
@@ -188,13 +234,16 @@ class ComponentDefinition
       componentType = "model" if Luca.isModelPrototype( definition )
 
       # automatically register this with the component registry
-      Luca.registerComponent( _.string.underscored(@componentId), @componentName, componentType)
+      type_alias = _.string.underscored(@componentId)
+      Luca.registerComponent( type_alias, @componentName, componentType)
 
     @defined = true
 
     unless _.isEmpty(@_classProperties)
       _.extend(definition, @_classProperties)
 
+
+
     definition?.afterDefinition?.call(definition, @)
 
     definition
@@ -212,7 +261,7 @@ cd.defaultsTo = cd.enhance = cd.with = cd.definePrototype
 
 cd.publicMethods = cd.publicInterface
 cd.privateMethods = cd.privateInterface
-cd.classMethods = cd.classInterface
+cd.classProperites = cd.classMethods = cd.classInterface
 
 _.extend (Luca.define = ComponentDefinition.create),
   __definitions: []
@@ -239,11 +288,15 @@ _.mixin def: Luca.define
 # and references to the classes and their prototypes, mainly for the purposes
 # of introspection and development tools
 Luca.extend = (superClassName, childName, properties={})->
-  superClass = Luca.util.resolve( superClassName, (window || global) )
+  superClassName  = Luca.util.checkDeprecationStatusOf(superClassName)
+  superClass      = Luca.util.resolve( superClassName, (window || global) )
 
   unless _.isFunction(superClass?.extend)
     throw "Error defining #{ childName }. #{ superClassName } is not a valid component to extend from"
 
+  superMetaData = Luca.registry.getMetaDataFor(superClassName)
+  superMetaData.descendants().push(childName)
+
   properties.displayName = childName
 
   properties._superClass = ()->
@@ -257,8 +310,6 @@ Luca.extend = (superClassName, childName, properties={})->
 
   definition = superClass.extend(properties)
 
-  # _.def("MyView").extends("View").with
-  #   include: ['Luca.Events']
   if _.isArray( properties?.include )
     for include in properties.include
       include = Luca.util.resolve(include) if _.isString(include)

data/app/assets/javascripts/luca/core/registry/index.coffee

@@ -0,0 +1,4 @@
+#= require ./concerns
+#= require ./component_definition
+#= require ./registry
+#= require ./meta_data

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

@@ -13,6 +13,8 @@ class MetaDataProxy
     _.defaults @meta, 
       "super class name" : ""
       "display name" : ""
+      "descendants": []
+      "aliases": []
       "public interface" : []
       "public configuration" : [] 
       "private interface" : []
@@ -20,6 +22,8 @@ class MetaDataProxy
       "class configuration" : []
       "class interface" : []
 
+  className: ()->
+    @meta["display name"]
   superClass: ()->
     Luca.util.resolve(@meta["super class name"])
 
@@ -75,6 +79,8 @@ class MetaDataProxy
   hooks: ()->
     @meta["hooks"]
 
+  descendants: ()->
+    @meta["descendants"] 
   styleHierarchy: ()->
     list = _( @classHierarchy() ).map (cls)->
       Luca.util.toCssClass(cls, 'views', 'components', 'core','fields','containers')

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

@@ -13,7 +13,10 @@ componentCacheStore =
 Luca.config.defaultComponentClass = Luca.defaultComponentClass  = 'Luca.View'
 Luca.config.defaultComponentType  = Luca.defaultComponentType   = 'view'
 
-Luca.registry.aliases = 
+Luca.registry.deprecatedComponents = {}
+Luca.registry.componentAliases = {}
+
+Luca.registry.typeAliases = 
   grid:         "grid_view"
   form:         "form_view"
   text:         "text_field"
@@ -27,7 +30,6 @@ Luca.registry.aliases =
   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:
@@ -36,24 +38,23 @@ Luca.registerComponent = (component, prototypeName, componentType="view")->
 
   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
 
-Luca.development_mode_register = (component, prototypeName)->
-  existing = registry.classes[component]
-
-  if Luca.enableDevelopmentTools is true and existing?
-    prototypeDefinition = Luca.util.resolve( existing, window)
-
+  if existing? and Luca.config.developmentMode is true 
     liveInstances = Luca.registry.findInstancesByClassName( prototypeName )
+    if liveInstances.length > 0
+      existingInstance.refreshEventBindings?() for existingInstance in liveInstances
 
-    _( liveInstances ).each (instance)->
-      instance?.refreshCode?.call(instance, prototypeDefinition)
-
-  Luca.registerComponent( component, prototypeName )
 
 # We create a @ctype alias for this component definition, and register
 # the class in a registry.
@@ -80,7 +81,7 @@ Luca.registry.namespaces = (resolve=true)->
 # by it's type identifier.  If it doesn't exist,
 # check any other registered namespace
 Luca.registry.lookup = (ctype)->
-  if alias = Luca.registry.aliases[ ctype ] 
+  if alias = Luca.registry.typeAliases[ ctype ] 
     ctype = alias
     
   c = registry.classes[ctype]
@@ -120,7 +121,12 @@ Luca.registry.classes = (toString=false)->
 Luca.registry.find = (search)->
   Luca.util.resolve(search) || Luca.define.findDefinition(search)
 
-Luca.cache = Luca.cacheInstance = (cacheKey, object)->
+Luca.remove = Luca.registry.removeInstance = (cacheKey)->
+  return unless cacheKey?
+  _( componentCacheStore.name_index ).delete( cacheKey )
+  _( componentCacheStore.cid_index ).delete( cacheKey )
+
+Luca.cache = Luca.registry.cacheInstance = (cacheKey, object)->
   return unless cacheKey?
   return object if object?.doNotCache is true
 

data/app/assets/javascripts/luca/core/templates.coffee

@@ -0,0 +1,51 @@
+Luca.templates ||= {}
+
+if window.JST?
+  for templateId, templateFn of JST when templateId.match(/^luca\/templates\//)
+    Luca.templates[ templateId.replace('luca/templates/','') ] = templateFn
+    _( JST ).delete( templateId )
+
+# This is a convenience method for accessing the templates
+# available to the client side app, either the ones which ship with Luca
+# available in Luca.templates ( these take precedence ) or
+# the app's own templates which are usually available in JST
+
+# optionally, passing in variables will compile the template for you, instead
+# of returning a reference to the function which you would then call yourself
+Luca.template = (template_name, variables, partials)->
+  window.JST ||= {}
+
+  if _.isFunction(template_name)
+    return template_name(variables)
+
+  luca = Luca.templates?[ template_name ]
+  jst = JST?[ template_name ]
+
+  unless luca? or jst?
+    needle = new RegExp("#{ template_name }$")
+
+    luca = _( Luca.templates ).detect (fn,template_id)->
+      needle.exec( template_id )
+
+    jst = _( JST ).detect (fn,template_id)->
+      needle.exec( template_id )
+
+  throw "Could not find template named #{ template_name }" unless luca || jst
+
+  template = luca || jst
+
+  if template instanceof Hogan.template
+    if variables?
+      return template.render(variables, partials)
+
+  return template(variables) if variables?
+
+  template
+
+Luca.available_templates = (filter="")->
+  available = _( Luca.templates ).keys()
+
+  if filter.length > 0
+    _( available ).select (tmpl)-> tmpl.match(filter)
+  else
+    available