luca 0.9.2 → 0.9.4

data/src/core/model.coffee

@@ -1,25 +1,40 @@
-# Luca.Model
+# Computed Properties Support
+# ###
 #
-# Luca.Model is an extenstion of Backbone.Model which provides
-# few useful patterns:
+# 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.  
 #
-#   - computed properties support
-_.def('Luca.Model').extends('Backbone.Model').with
-  initialize: ()->
-    Backbone.Model::initialize @, arguments
+# 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 = {}
 
-    return if _.isUndefined(@computed)
+  for attr, dependencies of @computed
+    @on "change:#{attr}", ()=>
+      @_computed[attr] = @[attr].call @
 
-    @_computed = {}
+    dependencies = dependencies.split(',') if _.isString(dependencies)
 
-    for attr, dependencies of @computed
-      @on "change:#{attr}", ()=>
-        @_computed[attr] = @[attr].call @
+    _(dependencies).each (dep)=>
+      @on "change:#{dep}", ()=>
+        @trigger "change:#{attr}"
+        
+      @trigger "change:#{attr}" if @has(dep) 
 
-      _(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)

data/src/core/panel.coffee

@@ -43,55 +43,12 @@ _.def("Luca.components.Panel").extends("Luca.View").with
   loadMask: false
   loadMaskTemplate: ["components/load_mask"]
   loadMaskTimeout: 3000
+  
+  mixins:["LoadMaskable"]
 
   initialize: (@options={})->
     Luca.View::initialize.apply(@, arguments)
-
-    _.bindAll @, "applyLoadMask", "disableLoadMask"
-
-    if @loadMask is true
-      @defer ()=>
-        @$el.addClass('with-mask')
-
-        if @$('.load-mask').length is 0
-          @loadMaskTarget().prepend Luca.template(@loadMaskTemplate, @)
-          @$('.load-mask').hide()
-      .until("after:render")
-
-      @on "enable:loadmask", @applyLoadMask
-      @on "disable:loadmask", @applyLoadMask
-
-  loadMaskTarget: ()->
-    if @loadMaskEl? then @$(@loadMaskEl) else @$bodyEl()
-
-  disableLoadMask: ()->
-    @$('.load-mask .bar').css("width","100%")
-    @$('.load-mask').hide()
-    clearInterval(@loadMaskInterval)
-
-  enableLoadMask: ()->
-    @$('.load-mask').show().find('.bar').css("width","0%")
-    maxWidth = @$('.load-mask .progress').width()
-    if maxWidth < 20 and (maxWidth = @$el.width()) < 20
-      maxWidth = @$el.parent().width()
-
-    @loadMaskInterval = setInterval ()=>
-      currentWidth = @$('.load-mask .bar').width()
-      newWidth = currentWidth + 12
-      @$('.load-mask .bar').css('width', newWidth)
-    , 200
-
-    return unless @loadMaskTimeout?
-
-    _.delay ()=>
-      @disableLoadMask()
-    , @loadMaskTimeout
-
-  applyLoadMask: ()->
-    if @$('.load-mask').is(":visible")
-      @disableLoadMask()
-    else
-      @enableLoadMask()
+    
 
   applyStyles: (styles={},body=false)->
 
@@ -137,6 +94,9 @@ _.def("Luca.components.Panel").extends("Luca.View").with
   $template: (template, variables={})->
     @$html( Luca.template(template,variables) )
 
+  $empty: ()->
+    @$bodyEl().empty()
+    
   $html: (content)->
     @$bodyEl().html( content )
 

data/src/core/registry.coffee

@@ -61,10 +61,24 @@ Luca.registry.namespaces = (resolve=true)->
   _( registry.namespaces ).map (namespace)->
     if resolve then Luca.util.resolve( namespace ) else namespace
 
+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"
+
 # Lookup a component in the Luca component registry
 # by it's ctype identifier.  If it doesn't exist,
 # check any other registered namespace
 Luca.registry.lookup = (ctype)->
+  if alias = Luca.registry.aliases[ ctype ] 
+    ctype = alias
+    
   c = registry.classes[ctype]
 
   return c if c?
@@ -76,13 +90,16 @@ Luca.registry.lookup = (ctype)->
   fullPath = _( parents ).chain().map((parent)->
     parent[className]).compact().value()?[0]
 
+Luca.registry.instances = ()->
+  _( component_cache.cid_index ).values()
+  
 Luca.registry.findInstancesByClassName = (className)->
-  instances = _( component_cache.cid_index ).values()
+  instances = Luca.registry.instances() 
   _( instances ).select (instance)->
     instance.displayName is className or instance._superClass?()?.displayName is className
 
 Luca.registry.classes = (toString=false)->
-  _( registry.classes ).map (className, ctype)->
+  _(_.extend({},registry.classes,registry.model_classes,registry.collection_classes)).map (className, ctype)->
     if toString
       className
     else

data/src/core/script_loader.coffee

@@ -0,0 +1,32 @@
+class Luca.ScriptLoader
+  @loaded: {}
+
+  constructor: (options={})->
+    _.extend(@, Backbone.Events, Luca.Events)
+    @autoStart = options.autoStart is true
+    @scripts = options.scripts
+
+    ready = ()-> @trigger("ready")
+
+    @ready = _.after( @scripts.length, ready)
+
+    _.bindAll @, "load", "ready"
+
+    @defer("load").until(@, "start")
+
+    if @autoStart is true
+      @trigger("start")
+
+    @bind "ready", @onReady
+
+  applyPrefix: (script)->
+    script
+
+  onReady: ()->
+    console.log "All dependencies loaded"
+
+  start: ()->
+    @trigger("start")
+
+  load: ()->
+    Luca.util.loadScript( @applyPrefix(script), @ready ) for script in @scripts

data/src/core/view.coffee

@@ -1,27 +1,8 @@
-#### Luca Base View
-
-# The Luca.View class adds some very commonly used patterns
-# and functionality to the stock Backbone.View class. Features
-# such as auto event binding, the facilitation of deferred rendering
-# against a Backbone.Model or Backbone.Collection reset event, Caching
-# views into a global Component Registry, and more.
-
 _.def("Luca.View").extends("Backbone.View").with
+  include: ['Luca.Events']
 
   additionalClassNames:[]
 
-  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
-
   hooks:[
     "after:initialize"
     "before:render"
@@ -32,39 +13,64 @@ _.def("Luca.View").extends("Backbone.View").with
   ]
 
   initialize: (@options={})->
+    @trigger "before:initialize", @, @options
 
     _.extend @, @options
 
     @cid = _.uniqueId(@name) if @name?
 
+    templateVars = if @bodyTemplateVars
+      @bodyTemplateVars.call(@)
+    else
+      @
+
     if template = @bodyTemplate
       @$el.empty()
-      Luca.View::$html.call(@, Luca.template(template, @) )
+      Luca.View::$html.call(@, Luca.template(template, templateVars ) )
 
-    #### View Caching
-    #
-    # Luca.View(s) which get created get stored in a global cache by their
-    # component id.  This allows us to re-use views when it makes sense
     Luca.cache( @cid, @ )
 
-    unique = _( Luca.View.prototype.hooks.concat( @hooks ) ).uniq()
-
-    @setupHooks( unique )
+    @setupHooks _( Luca.View::hooks.concat( @hooks ) ).uniq()
 
-    if @autoBindEventHandlers is true
-      @bindAllEventHandlers()
+    bindAllEventHandlers.call(@) if @autoBindEventHandlers is true or @bindAllEvents is true
 
     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
 
-    @trigger "after:initialize", @
+    @$wrap( @wrapperClass ) if @wrapperClass?
 
-    @registerCollectionEvents()
+    registerCollectionEvents.call(@)
+    registerApplicationEvents.call( @)
 
     @delegateEvents()
 
-  #### JQuery / DOM Selector Helpers
+    if @stateful is true and not @state?
+      @state = new Backbone.Model(@defaultState || {})
+      unless @set?
+        @set = _.bind @, @state.set
+        @get = _.bind @, @state.get
+
+    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)
@@ -80,17 +86,12 @@ _.def("Luca.View").extends("Backbone.View").with
   $append: (content)->
     @$el.append( content )
 
-  #### Containers
-  #
-  # Luca is heavily reliant on the concept of Container views.  Views which
-  # contain other views and handle inter-component communication between the
-  # component views.  The default render() operation consists of building the
-  # view's content, and then attaching that view to its container.
-  #
-  # 99% of the time this would happen automatically
   $attach: ()->
     @$container().append( @el )
 
+  $bodyEl: ()->
+    @$el
+    
   $container: ()->
     $(@container)
 
@@ -120,120 +121,38 @@ _.def("Luca.View").extends("Backbone.View").with
 
       @bind eventId, callback
 
-
-  #### Luca.Collection and Luca.CollectionManager integration
-
-  # under the hood, this will find your collection manager using
-  # Luca.CollectionManager.get, which is a function that returns
-  # the first instance of the CollectionManager class ever created.
-  #
-  # if you want to use more than one collection manager, over ride this
-  # function in your views with your own logic
-  getCollectionManager: ()->
-    @collectionManager || Luca.CollectionManager.get?()
-
-  ##### Collection Events
-  #
-  # By defining a hash of collectionEvents in the form of
-  #
-  # "books add" : "onBookAdd"
-  #
-  # the Luca.View will bind to the collection found in the
-  # collectionManager with that key, and bind to that event.
-  # a property of @booksCollection will be created on the view,
-  # and the "add" event will trigger "onBookAdd"
-  #
-  # you may also specify a function directly.  this
-  #
-  registerCollectionEvents: ()->
-    manager = @getCollectionManager()
-
-    _( @collectionEvents ).each (handler, signature)=>
-      [key,event] = signature.split(" ")
-
-      collection = @["#{ key }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(event, handler)
-      catch e
-        console.log "Error Binding To Collection in registerCollectionEvents", @
-        throw e
-
   registerEvent: (selector, handler)->
     @events ||= {}
     @events[ selector ] = handler
     @delegateEvents()
 
-  bindAllEventHandlers: ()->
-    _( @events ).each (handler,event)=>
-      if _.isString(handler)
-        _.bindAll @, handler
-
   definitionClass: ()->
     Luca.util.resolve(@displayName, window)?.prototype
 
-  # refreshCode happens whenever the Luca.Framework extension
-  # system is run after there are running instances of a given component
-
-  # in the context of views, what this means is that each eventHandler which
-  # is bound to a specific object via _.bind or _.bindAll, or autoBindEventHandlers
-  # is refreshed with the prototype method of the component that it inherits from,
-  # and then delegateEvents is called to refresh any of the updated event handlers
-
-  # in addition to this, all properties of the instance of a given view which are
-  # also backbone views will have the same process run against them
-  refreshCode: ()->
-    view = @
-
-    _( @eventHandlerProperties() ).each (prop)->
-      view[ prop ] = view.definitionClass()[prop]
-
-    if @autoBindEventHandlers is true
-      @bindAllEventHandlers()
-
-    @delegateEvents()
-
-  eventHandlerProperties: ()->
-    handlerIds = _( @events ).values()
-    _( handlerIds ).select (v)->
-      _.isString(v)
-
-  eventHandlerFunctions: ()->
-    handlerIds = _( @events ).values()
-    _( handlerIds ).map (handlerId)=>
-      if _.isFunction(handlerId) then handlerId else @[handlerId]
-
   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)->
-  #### Rendering
-  #
-  # Our base view class wraps the defined render() method
-  # of the views which inherit from it, and does things like
-  # trigger the before and after render events automatically.
-  # In addition, if the view has a deferrable property on it
-  # then it will make sure that the render method doesn't get called
-  # until.
-
   _base = definition.render
 
   _base ||= Luca.View::$attach
 
-
   definition.render = ()->
     view = @
     # if a view has a deferrable property set
@@ -274,10 +193,64 @@ customizeRender = (definition)->
 
   definition
 
-# By overriding Backbone.View.extend we are able to intercept
-# some method definitions and add special behavior around them
-# mostly related to render()
+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
+
+
 Luca.View.extend = (definition)->
   definition = customizeRender( definition )
-  originalExtend.call(@, definition)
 
+  if definition.mixins? and _.isArray( definition.mixins )
+    _.extend(definition, Luca.modules[module]) for module in definition.mixins
+
+  originalExtend.call(@, definition)

data/src/define.coffee

@@ -0,0 +1,110 @@
+# Component Definition Helpers
+#
+#
+# We have customized the core Backbone.extend process to use a slightly
+# different syntax, which allows us to intercept the component definition at
+# various points, and maintain information about classes being defined, and
+# the relationships between inherited classes, etc.
+
+# _.def, or Luca.define returns a chainable object which allows you to define
+# your components with a readable syntax.  For example:
+
+# _.def("Luca.View").extends("Backbone.View").with the_good:"shit"
+# _.def("MyView").extends("Luca.View").with the_custom:"shit"
+
+Luca.define = (componentName)->
+  new DefineProxy(componentName)
+
+Luca.component = Luca.define
+
+# The define proxy chain sets up a call to Luca.extend, which is a wrapper around Luca and Backbone component class' extend function.
+class DefineProxy
+  constructor:(componentName)->
+    @namespace = Luca.util.namespace()
+    @componentId = @componentName = componentName
+
+    if componentName.match(/\./)
+      @namespaced = true
+      parts = componentName.split('.')
+      @componentId = parts.pop()
+      @namespace = parts.join('.')
+
+      # automatically add the namespace to the namespace registry
+      Luca.registry.addNamespace( parts.join('.') )
+
+  # allow for specifying the namespace
+  in: (@namespace)-> @
+
+  # allow for multiple ways of saying the same thing for readability purposes
+  from: (@superClassName)-> @
+  extends: (@superClassName)-> @
+  extend: (@superClassName)-> @
+
+  # an alias for with, or a readability helper in multi-line definitions
+  enhance: (properties)->
+    return @with(properties) if properties?
+    @
+
+  # which properties, methods, etc will you be extending the base class with?
+  with: (properties)->
+    at = if @namespaced
+      Luca.util.resolve(@namespace, (window || global))
+    else
+      (window||global)
+
+    # automatically create the namespace
+    if @namespaced and not at?
+      eval("(window||global).#{ @namespace } = {}")
+      at = Luca.util.resolve(@namespace,(window || global))
+
+    at[@componentId] = Luca.extend(@superClassName,@componentName, properties)
+
+    if Luca.autoRegister is true 
+      componentType = "view" if Luca.isViewPrototype( at[@componentId] )
+
+      if Luca.isCollectionPrototype( at[@componentId] )
+        Luca.Collection.namespaces ||= []
+        Luca.Collection.namespaces.push( @namespace )
+        componentType = "collection" 
+
+      componentType = "model" if Luca.isModelPrototype( at[@componentId] )
+
+      # automatically register this with the component registry
+      Luca.register( _.string.underscored(@componentId), @componentName, componentType)
+
+    at[@componentId]
+
+# The last method of the DefineProxy chain is always going to result in
+# a call to Luca.extend.  Luca.extend wraps the call to Luca.View.extend,
+# or Backbone.Collection.extend, and accepts the names of the extending,
+# and extended classes as strings.  This allows us to maintain information
+# 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) )
+
+  unless _.isFunction(superClass?.extend)
+    throw "#{ superClassName } is not a valid component to extend from"
+
+  properties.displayName = childName
+
+  properties._superClass = ()->
+    superClass.displayName ||= superClassName
+    superClass
+
+  properties._super = (method, context, args)->
+    @_superClass().prototype[method]?.apply(context, args)
+
+  definition = superClass.extend(properties)
+
+  # _.def("MyView").extends("View").with
+  #   include: ['Luca.Events']
+  if _.isArray( properties?.include )
+    for mixin in properties.include
+      mixin = Luca.util.resolve(mixin) if _.isString(mixin)
+      _.extend(definition::, mixin)
+
+  definition
+
+_.mixin
+  def: Luca.define

data/src/framework.coffee

@@ -19,7 +19,7 @@
     return fallback()
 
 _.extend Luca,
-  VERSION: "0.9.2"
+  VERSION: "0.9.4"
   core: {}
   containers: {}
   components: {}
@@ -27,6 +27,7 @@ _.extend Luca,
   util: {}
   fields: {}
   registry:{}
+  options: {}
 
 # for triggering / binding to component definitions
 _.extend Luca, Backbone.Events
@@ -79,21 +80,27 @@ Luca.isComponentPrototype = (obj)->
   Luca.isViewPrototype(obj) or Luca.isModelPrototype(obj) or Luca.isCollectionPrototype(obj)
 
 Luca.isBackboneModel = (obj)->
+  obj = Luca.util.resolve(obj) if _.isString(obj)
   _.isFunction(obj?.set) and _.isFunction(obj?.get) and _.isObject(obj?.attributes)
 
 Luca.isBackboneView = (obj)->
+  obj = Luca.util.resolve(obj) if _.isString(obj)
   _.isFunction(obj?.render) and !_.isUndefined(obj?.el)
 
 Luca.isBackboneCollection = (obj)->
+  obj = Luca.util.resolve(obj) if _.isString(obj)
   _.isFunction(obj?.fetch) and _.isFunction(obj?.reset)
 
 Luca.isViewPrototype = (obj)->
+  obj = Luca.util.resolve(obj) if _.isString(obj)
   obj? and obj::? and obj::make? and obj::$? and obj::render?
 
 Luca.isModelPrototype = (obj)->
+  obj = Luca.util.resolve(obj) if _.isString(obj)
   obj? and obj::? obj::save? and obj::changedAttributes?
 
 Luca.isCollectionPrototype = (obj)->
+  obj = Luca.util.resolve(obj) if _.isString(obj)
   obj? and obj::? and !Luca.isModelPrototype(obj) and obj::reset? and obj::select? and obj::reject?
 
 Luca.inheritanceChain = (obj)->
@@ -168,7 +175,6 @@ Luca.available_templates = (filter="")->
     available
 
 
-
 UnderscoreExtensions =
   module: (base,module)->
     _.extend base, module