luca 0.9.4 → 0.9.6

data/src/define.coffee

@@ -11,17 +11,15 @@
 
 # _.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
+_.mixin
+  def: Luca.component = Luca.define = Luca.register = (componentName)-> new DefineProxy(componentName)
 
 # 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
+    @superClassName = 'Luca.View' 
 
     if componentName.match(/\./)
       @namespaced = true
@@ -40,13 +38,30 @@ class DefineProxy
   extends: (@superClassName)-> @
   extend: (@superClassName)-> @
 
-  # an alias for with, or a readability helper in multi-line definitions
-  enhance: (properties)->
-    return @with(properties) if properties?
+  triggers: (hooks...)->
+    _.defaults(@properties ||= {}, hooks: []) 
+    for hook in hooks
+      @properties.hooks.push(hook) 
+    @properties.hooks = _.uniq(@properties.hooks)
+    @
+
+  includes: (includes...)->
+    _.defaults(@properties ||= {}, include: []) 
+    for include in includes
+      @properties.include.push(include) 
+    @properties.include = _.uniq(@properties.include)
+    @
+
+  mixesIn: (mixins...)->
+    _.defaults(@properties ||= {}, mixins: []) 
+    for mixin in mixins
+      @properties.mixins.push(mixin) 
+    @properties.mixins = _.uniq(@properties.mixins)
     @
 
-  # which properties, methods, etc will you be extending the base class with?
-  with: (properties)->
+  defaultProperties: (properties={})->
+    _.defaults((@properties||={}), properties)
+
     at = if @namespaced
       Luca.util.resolve(@namespace, (window || global))
     else
@@ -57,7 +72,7 @@ class DefineProxy
       eval("(window||global).#{ @namespace } = {}")
       at = Luca.util.resolve(@namespace,(window || global))
 
-    at[@componentId] = Luca.extend(@superClassName,@componentName, properties)
+    at[@componentId] = Luca.extend(@superClassName,@componentName, @properties)
 
     if Luca.autoRegister is true 
       componentType = "view" if Luca.isViewPrototype( at[@componentId] )
@@ -70,10 +85,17 @@ class DefineProxy
       componentType = "model" if Luca.isModelPrototype( at[@componentId] )
 
       # automatically register this with the component registry
-      Luca.register( _.string.underscored(@componentId), @componentName, componentType)
+      Luca.registerComponent( _.string.underscored(@componentId), @componentName, componentType)
 
     at[@componentId]
 
+# Aliases for the mixin definition
+DefineProxy::behavesAs = DefineProxy::uses = DefineProxy::mixesIn 
+
+# Aliases for the final call on the define proxy
+DefineProxy::defines = DefineProxy::defaults = DefineProxy::exports = DefineProxy::defaultProperties 
+DefineProxy::defaultsTo = DefineProxy::enhance = DefineProxy::with = DefineProxy::defaultProperties
+
 # 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,
@@ -83,8 +105,10 @@ class DefineProxy
 Luca.extend = (superClassName, childName, properties={})->
   superClass = Luca.util.resolve( superClassName, (window || global) )
 
+  superClass.__initializers ||= []
+
   unless _.isFunction(superClass?.extend)
-    throw "#{ superClassName } is not a valid component to extend from"
+    throw "Error defining #{ childName }. #{ superClassName } is not a valid component to extend from"
 
   properties.displayName = childName
 
@@ -92,7 +116,10 @@ Luca.extend = (superClassName, childName, properties={})->
     superClass.displayName ||= superClassName
     superClass
 
-  properties._super = (method, context, args)->
+  properties._super = (method, context=@, args=[])->
+    # protect against a stack too deep error in weird cases
+    # TODO: debug this better
+    
     @_superClass().prototype[method]?.apply(context, args)
 
   definition = superClass.extend(properties)
@@ -100,11 +127,56 @@ Luca.extend = (superClassName, childName, 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)
+    for include in properties.include
+      include = Luca.util.resolve(include) if _.isString(include)
+      _.extend(definition::, include)
 
   definition
 
-_.mixin
-  def: Luca.define
+
+Luca.mixin = (mixinName)->
+  namespace = _( Luca.mixin.namespaces ).detect (space)->
+    Luca.util.resolve(space)?[ mixinName ]?
+
+  namespace ||= "Luca.modules"
+
+  resolved = Luca.util.resolve(namespace)[ mixinName ]
+
+  console.log "Could not find #{ mixinName } in ", Luca.mixin.namespaces unless resolved?
+
+  resolved
+
+Luca.mixin.namespaces = [
+  "Luca.modules"
+]
+
+Luca.mixin.namespace = (namespace)->
+  Luca.mixin.namespaces.push(namespace)
+  Luca.mixin.namespaces = _( Luca.mixin.namespaces ).uniq()
+
+# Luca.decorate('Luca.View').with('Luca.modules.MyCustomMixin')
+Luca.decorate = (componentPrototype)->
+  componentPrototype = Luca.util.resolve(componentPrototype).prototype if _.isString(componentPrototype)
+  
+  return with: (mixin)->
+    mixinDefinition = Luca.mixin(mixin)
+
+    mixinPrivates   = _( mixinDefinition ).chain().keys().select (key)-> 
+      "#{ key }".match(/^__/)
+
+    sanitized   = _( mixinDefinition ).omit( mixinPrivates.value() )
+
+    _.extend(componentPrototype, sanitized)
+
+    # When a mixin is included, we may want to do things 
+    mixinDefinition?.__included?.call(mixinDefinition, mixin) 
+
+    superclassMixins = componentPrototype._superClass()::mixins
+
+    componentPrototype.mixins ||= []
+    componentPrototype.mixins.push( mixin )
+    componentPrototype.mixins = componentPrototype.mixins.concat( superclassMixins )
+
+    componentPrototype.mixins = _( componentPrototype.mixins ).chain().uniq().compact().value()
+
+    componentPrototype

data/src/framework.coffee

@@ -19,7 +19,7 @@
     return fallback()
 
 _.extend Luca,
-  VERSION: "0.9.4"
+  VERSION: "0.9.6"
   core: {}
   containers: {}
   components: {}
@@ -28,27 +28,30 @@ _.extend Luca,
   fields: {}
   registry:{}
   options: {}
+  config: {}
 
 # for triggering / binding to component definitions
 _.extend Luca, Backbone.Events
 
 # When using Luca.define() should we automatically register
 # the component with the registry?
-Luca.autoRegister = true
+Luca.autoRegister = Luca.config.autoRegister = true
 
 # if developmentMode is true, you have access to some neat development tools
-Luca.developmentMode = false
+Luca.developmentMode = Luca.config.developmentMode = false
 
 # The Global Observer is very helpful in development
 # it observes every event triggered on every view, collection, model
 # and allows you to inspect / respond to them.  Use in production
 # may have performance impacts which has not been tested
-Luca.enableGlobalObserver = false
+Luca.enableGlobalObserver = Luca.config.enableGlobalObserver = false
 
 # let's use the Twitter 2.0 Bootstrap Framework
 # for what it is best at, and not try to solve this
 # problem on our own!
-Luca.enableBootstrap = true
+Luca.enableBootstrap = Luca.config.enableBootstrap = true
+
+Luca.config.enhancedViewProperties = true
 
 Luca.keys =
   ENTER: 13
@@ -66,9 +69,8 @@ Luca.keyMap = _( Luca.keys ).inject (memo, value, symbol)->
   memo
 , {}
 
-Luca.find = ()->
-  # TODO Implement
-  undefined
+Luca.find = (el)->
+  Luca( $(el).data('luca-id') )
 
 Luca.supportsEvents = Luca.supportsBackboneEvents = (obj)->
   Luca.isComponent(obj) or (_.isFunction( obj?.trigger ) or _.isFunction(obj?.bind))

data/src/index.coffee

@@ -0,0 +1,23 @@
+#= require ./util
+#= require_tree ./plugins
+#= require ./define
+
+#= require_tree ./modules
+
+#= require ./core/registry
+#= require ./core/observer
+#= require ./core/view
+#= require ./core/model
+#= require ./core/collection
+#= require ./core/panel
+#= require ./core/field
+#= require ./core/container
+
+#= require_tree ./managers
+
+#= require ./containers/split_view
+#= require ./containers/column_view
+#= require_tree ./containers
+
+#= require ./components/template
+#= require_tree ./components

data/src/managers/collection_manager.coffee

@@ -45,7 +45,11 @@ class Luca.CollectionManager
     CollectionClass ||= guessCollectionClass.call(@, key)
     collectionOptions.name = "" if collectionOptions.private
 
-    collection = new CollectionClass(initialModels,collectionOptions)
+    try  
+      collection = new CollectionClass(initialModels,collectionOptions)
+    catch e
+      console.log "Error creating collection", CollectionClass, collectionOptions, key
+      throw(e)
 
     @add(key, collection)
 
@@ -97,9 +101,23 @@ class Luca.CollectionManager
   private: (key, collectionOptions={}, initialModels=[])->
     @create(key,collectionOptions,initialModels,true)
 
+#### Helpers
+
+Luca.CollectionManager.isRunning = ()->
+  _.isEmpty( Luca.CollectionManager.instances ) isnt true
+
 Luca.CollectionManager.destroyAll = ()-> 
   Luca.CollectionManager.instances = {} 
 
+Luca.CollectionManager.loadCollectionsByName = (set, callback)->
+  for name in set 
+    collection = @getOrCreate(name)
+    collection.once "reset", ()->
+      callback(collection)
+    collection.fetch()  
+
+
+#### Private Methods
 guessCollectionClass = (key)->
   classified = Luca.util.classify( key )
   # support our naming convention of Books
@@ -120,16 +138,13 @@ guessCollectionClass = (key)->
 loadInitialCollections = ()->
   collectionDidLoad = (collection) =>
     current = @state.get("loaded_collections_count")
-
     @state.set("loaded_collections_count", current + 1)
     @trigger "collection_loaded", collection.name
     collection.unbind "reset"
 
-  _(@initialCollections).each (name) =>
-    collection = @getOrCreate(name)
-    collection.once "reset", ()->
-      collectionDidLoad(collection)
-    collection.fetch()
+  set = @initialCollections
+  Luca.CollectionManager.loadCollectionsByName.call(@, set, collectionDidLoad)
+
 
 handleInitialCollections = ()->
   @state.set({loaded_collections_count: 0, collections_count: @initialCollections.length })
@@ -140,4 +155,5 @@ handleInitialCollections = ()->
 
   loadInitialCollections.call(@)
 
-  @
+  @initialCollectionsLoadedu
+  @

data/src/modules/application_event_bindings.coffee

@@ -0,0 +1,19 @@
+Luca.modules.ApplicationEventBindings = 
+  __initializer: ()->
+    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)

data/src/modules/collection_event_bindings.coffee

@@ -0,0 +1,26 @@
+Luca.modules.CollectionEventBindings = 
+  __initializer: ()->
+    return if _.isEmpty( @collectionEvents )
+
+    manager = @collectionManager || Luca.CollectionManager.get()
+
+    for signature, handler of @collectionEvents
+      [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.on(eventTrigger, handler, collection)
+      catch e
+        console.log "Error Binding To Collection in registerCollectionEvents", @
+        throw e
+

data/src/modules/deferrable.coffee

@@ -1,4 +1,6 @@
-# TODO THis module is going to be deprecated as it has been gradually gut over time
+# TODO
+# 
+# This is horrendous code.  I need to replace it ASAP
 Luca.modules.Deferrable = 
   configure_collection: (setAsDeferrable=true)->
     return unless @collection

data/src/modules/dom_helpers.coffee

@@ -0,0 +1,49 @@
+Luca.modules.DomHelpers = 
+  __initializer: ()->
+    additionalClasses = _( @additionalClassNames || [] ).clone()
+
+    @$wrap( @wrapperClass ) if @wrapperClass?
+
+    if _.isString additionalClasses
+      additionalClasses = additionalClasses.split(" ")
+
+    if @gridSpan
+      additionalClasses.push "span#{ @gridSpan }"
+
+    if @gridOffset
+      additionalClasses.push "offset#{ @gridOffset }"
+
+    if @gridRowFluid
+      additionalClasses.push "row-fluid"
+
+    if @gridRow
+      additionalClasses.push "row"
+
+    return unless additionalClasses?
+
+    for additional in additionalClasses
+      @$el.addClass( additional )     
+
+  $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)  

data/src/modules/enhanced_properties.coffee

@@ -0,0 +1,23 @@
+Luca.modules.EnhancedProperties = 
+  __initializer: ()->
+    return unless Luca.config.enhancedViewProperties is true 
+
+    # The @collection property.
+    #
+    # If the @collection property is a string, then upon initialization
+    # of the view, that @collection property will be swapped out
+    # with the instance of the collection of that name in the main
+    # Luca.CollectionManager
+    if _.isString(@collection) and Luca.CollectionManager.get()
+      @collection = Luca.CollectionManager.get().getOrCreate(@collection)      
+
+    # The @template property.
+    #
+    # For simple views which only need a template, you can specify the
+    # template by its name, and we will render it for you.
+    if @template?
+      @$template(@template, @)
+
+    # The @collectionManager property is also configurable by string
+    if _.isString( @collectionManager )
+      @collectionManager = Luca.CollectionManager.get( @collectionManager )

data/src/modules/filterable.coffee

@@ -0,0 +1,60 @@
+Luca.modules.Filterable = 
+  __included: (component, module)->
+    _.extend(Luca.Collection::, __filters:{})
+
+  __initializer: (component, module)->
+    return if @filterable is false or not Luca.isBackboneCollection(@collection) 
+
+    @getCollection ||= ()-> @collection
+
+    filter = @getFilterState()
+
+    filter.on "change", (state)=>
+      @trigger "collection:change:filter", state, @getCollection()
+      @trigger "refresh" 
+
+    if @getQuery?
+      @getQuery = _.compose @getQuery, (query={})->
+        obj = _.clone(query)
+        _.extend(obj, filter.toQuery() )
+    else
+      @getQuery = ()=>
+        filter.toQuery()
+
+    if @getQueryOptions?
+      @getQueryOptions = _.compose @getQueryOptions, (options={})->
+        obj = _.clone(options)
+        _.extend(obj, filter.toOptions() )
+    else
+      @getQueryOptions = ()-> filter.toOptions()
+
+  getFilterState: ()->
+    @collection.__filters[ @cid ] ||= new FilterModel(@filterable)
+
+  setSortBy: (sortBy, options={})->
+   @getFilterState().setOption('sortBy', sortBy, options)
+
+  applyFilter: (query={}, options={})->
+    options = _.defaults(options, @getQueryOptions())
+    query = _.defaults(query, @getQuery())
+
+    silent = _( options ).delete('silent') is true
+
+    @getFilterState().set({query,options}, silent: silent)
+
+class FilterModel extends Backbone.Model
+  setOption: (option, value, options)->
+    payload = {}
+    payload[option] = value
+    @set 'options', _.extend(@toOptions(), payload), options
+
+  setQueryOption: (option, value, options)->
+    payload = {}
+    payload[option] = value
+    @set 'query', _.extend(@toQuery(), payload), options
+
+  toOptions: ()->
+    @toJSON().options
+
+  toQuery: ()->
+    @toJSON().query