luca 0.9.7 → 0.9.8

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

@@ -1,12 +1,11 @@
 collection = Luca.define            'Luca.Collection'
-
-if Backbone.QueryCollection?
-  collection.extends                'Backbone.QueryCollection'
-else
-  collection.extends                'Backbone.Collection'
-
+collection.extends                  'Backbone.QueryCollection'
 collection.includes                 'Luca.Events'
 
+collection.triggers                 "after:initialize",  
+                                    "before:fetch",
+                                    "after:response"
+
 collection.defines    
   model: Luca.Model
   # cachedMethods refers to a list of methods on the collection
@@ -25,7 +24,6 @@ collection.defines
 
   initialize: (models=[], @options)->
     _.extend @, @options
-    @setupMethodCaching()
     @_reset()
 
     # By specifying a @cache_key property or method, you can instruct
@@ -37,7 +35,7 @@ collection.defines
       console.log 'The @cached property of Luca.Collection is being deprecated.  Please change to cache_key'
 
     if @cache_key ||= @cached
-      @bootstrap_cache_key = if _.isFunction( @cache_key ) then @cache_key() else @cache_key
+      @bootstrap_cache_key = Luca.util.read(@cache_key) 
 
     if @registerAs or @registerWith
       console.log "This configuration API is deprecated.  use @name and @manager properties instead"
@@ -58,8 +56,8 @@ collection.defines
     # to be scoped with some sort of unique id, as say some sort of belongsTo relationship
     # then you can specify @registerAs as a method()
     if @manager
-      @name ||= @cache_key()
-      @name = if _.isFunction( @name ) then @name() else @name
+      @name ||= Luca.util.read(@cache_key) 
+      @name = Luca.util.read(@name) 
 
       unless @private or @anonymous
         @bind "after:initialize", ()=>
@@ -70,7 +68,7 @@ collection.defines
     # locally in localStorage
     if @useLocalStorage is true and window.localStorage?
       table = @bootstrap_cache_key || @name
-      throw "Must specify either a cached or registerAs property to use localStorage"
+      throw "Must specify a cache_key property or method to use localStorage"
       @localStorage = new Luca.LocalStore( table )
 
     # Populating a collection with local data
@@ -92,6 +90,9 @@ collection.defines
       @reset models, silent: true, parse: options?.parse
 
     Luca.concern.setup.call(@)
+    Luca.util.setupHooks.call(@, @hooks)
+
+    @setupMethodCaching()
 
     @trigger "after:initialize"
 
@@ -141,43 +142,43 @@ collection.defines
     @
 
   applyFilter: (filter={}, options={})->
+    options = _( options ).clone()
+
     if options.remote? is true or @remoteFilter is true
       @applyParams(filter)
-      @fetch _.extend(options,refresh:true)
+      @fetch _.extend(options,refresh:true,remote:true)
     else
-      @reset @query filter
+      @reset @query(filter, options)
 
   # You can apply params to a collection, so that any upcoming requests
   # made to the REST API are made with the key values specified
   applyParams: (params)->
-    @base_params = _( Luca.Collection.baseParams() ).clone()
+    @base_params = _( Luca.Collection.baseParams() ).clone() || {}
     _.extend @base_params, params
 
     @
 
-  # If this collection is to be registered with some global collection
-  # tracker such as new Luca.CollectionManager() then we will register
-  # ourselves automatically
-  #
-  # To automatically register a collection with the registry, instantiate
-  # it with the registerWith property, which can either be a reference to
-  # the manager itself, or a string in case the manager isn't available
-  # at compile time
-  register: (collectionManager=Luca.CollectionManager.get(), key="", collection)->
-    throw "Can not register with a collection manager without a key" unless key.length >= 1
-    throw "Can not register with a collection manager without a valid collection manager" unless collectionManager?
+  register: (collectionManager, key="", collection)->
+    collectionManager ||= Luca.CollectionManager.get()
+
+    unless key.length >= 1
+      throw "Attempt to register a collection without specifying a key." 
+
 
     # by passing a string instead of a reference to an object, we can look up
     # that object only when necessary.  this prevents us from having to create
     # the manager instance before we can define our collections
     if _.isString( collectionManager )
-      collectionManager = Luca.util.nestedValue( collectionManager, (window || global) )
+      collectionManager = Luca.util.resolve( collectionManager )
 
-    throw "Could not register with collection manager" unless collectionManager
+    unless collectionManager?
+      throw "Attempt to register with a non existent collection manager." 
 
     if _.isFunction( collectionManager.add )
       return collectionManager.add(key, collection)
 
+    # If we don't want to use the CollectionManager class, and just want
+    # to cache collection instances on an object, we can do that too.
     if _.isObject( collectionManager )
       collectionManager[ key ] = collection
 
@@ -232,10 +233,11 @@ collection.defines
   # reset trigger with a function wrapped in _.once
   # so that it only gets run...ahem...once.
   #
-  # that being said, if the collection already has models
   # it won't even bother fetching it it will just run
   # as if reset was already triggered
-  onceLoaded: (fn, options={autoFetch:true})->
+  onceLoaded: (fn, options={})->
+    _.defaults(options, autoFetch: true)
+
     if @length > 0 and not @fetching
       fn.apply @, [@]
       return
@@ -264,17 +266,6 @@ collection.defines
     unless @fetching is true or !options.autoFetch or @length > 0
       @fetch()
 
-  # parse is very close to the stock Backbone.Collection parse, which
-  # just returns the response.  However, it also triggers a callback
-  # after:response, and automatically parses responses which contain
-  # a JSON root like you would see in rails, if you specify the @root
-  # property.
-  #
-  # it will also update the Luca.Collection.cache with the models from
-  # the response, so that any subsequent calls to fetch() on a bootstrapped
-  # collection, will have updated models from the server.  Really only
-  # useful if you call fetch(refresh:true) manually on any bootstrapped
-  # collection
   parse: (response)->
     @fetching = false
     @trigger "after:response", response
@@ -304,6 +295,8 @@ collection.defines
       @clearMethodCache(name)
 
   setupMethodCaching: ()->
+    return unless @cachedMethods?.length > 0 
+
     collection = @
     membershipEvents = ["reset","add","remove"]
     cache = @_methodCache = {}
@@ -318,7 +311,7 @@ collection.defines
 
       # wrap the collection method with a basic memoize operation
       collection[ method ] = ()->
-        cache[method].value ||= cache[method].original.apply collection, arguments
+        cache[method].value ||= cache[method].original.apply(collection, arguments)
 
       # bind to events on the collection, which once triggered, will
       # invalidate the cached value.  causing us to have to restore it
@@ -329,7 +322,9 @@ collection.defines
       dependencies = method.split(':')[1]
 
       if dependencies
-        for dependency in dependencies.split(",")
+        watchForChangesOn = dependencies.split(",")
+
+        _( watchForChangesOn ).each (dependency)->
           collection.bind "change:#{dependency}", ()->
             collection.clearMethodCache(method: method)
 
@@ -337,9 +332,17 @@ collection.defines
   # make sure the querying interface from backbone.query is present
   # in the case backbone-query isn't loaded.  without it, it will
   # just return the models
+  #
+  # TODO:
+  # 
+  # Currently the View mixins: Filterable, Sortable, and Paginatable
+  # implement a lot of logic that belongs in this interface.
   query: (filter={},options={})->
     if Backbone.QueryCollection?
-      return Backbone.QueryCollection::query.apply(@, arguments)
+      if _.isFunction(prepare = options.prepare || @prepareQuery)
+        filter = prepare(filter) 
+
+      return Backbone.QueryCollection::query.call(@, filter, options)
     else
       @models
 
@@ -366,18 +369,24 @@ Luca.Collection.extend = (definition={})->
 
   componentClass
 
+Luca.Collection.namespace = (namespace)->
+  namespace = Luca.util.resolve(namespace) if _.isString(namespace)
+  Luca.Collection.__defaultNamespace = namespace if namespace?
+  Luca.Collection.__defaultNamespace ||= (window || global)
+  Luca.util.read( Luca.Collection.__defaultNamespace )
+  
 # Always include these parameters in every request to your REST API.
 #
 # either specify a function which returns a hash, or just a normal hash
 Luca.Collection.baseParams = (obj)->
-  return Luca.Collection._baseParams = obj if obj
-
-  if _.isFunction( Luca.Collection._baseParams )
-    return Luca.Collection._baseParams()
+  obj = Luca.util.resolve(obj) if _.isString(obj)
+  Luca.Collection._baseParams = obj if obj
 
-  if _.isObject( Luca.Collection._baseParams )
-    Luca.Collection._baseParams
+  Luca.util.read( Luca.Collection._baseParams )
 
+Luca.Collection.resetBaseParams = ()->
+  Luca.Collection._baseParams = {}
+  
 # In order to make our Backbone Apps super fast it is a good practice
 # to pre-populate your collections by what is referred to as bootstrapping
 #

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

@@ -9,7 +9,7 @@
 # or
 #
 # view.defer( myCallback ).until("triggered:event")
-class DeferredBindingProxy
+class Luca.DeferredBindingProxy
   constructor: (@object, operation, wrapWithUnderscore=true)->
     if _.isFunction(operation)
       fn = operation
@@ -41,10 +41,42 @@ class DeferredBindingProxy
 
     @object
 
+class Luca.EventRelayer
+  constructor: (options={})->
+    {@target,@events,@prefix,@source} = options
+
+    if @events.length > 0 and @target and @source
+      @setup()
+    @
+
+  prefixedBy: (@prefix="")->
+    @
+
+  from:(@source)->
+    @
+
+  to: (@target)->
+    @
+
+  setup: (@target)->
+    prefix = @prefix
+    target = @target
+
+    for eventId in @events
+      console.log "Binding to ", eventId, prefix, @target.name, @source.name
+      @source.on eventId, (args...)->
+        trigger = _( [prefix,eventId] ).compact().join(':')
+        args.unshift(trigger)
+        @trigger.apply(@, args)
+      , target 
+
+
 Luca.Events =
+  relays: (events...)->
+    new Luca.EventRelayer(relayer: @, events: events)
 
   defer: (operation, wrapWithUnderscore=true)->
-    new DeferredBindingProxy(@, operation, wrapWithUnderscore)
+    new Luca.DeferredBindingProxy(@, operation, wrapWithUnderscore)
 
   once: (trigger, callback, context)->
     context ||= @

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,112 @@
+# 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.mixesIn                   "LoadMaskable"
+
+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 )
+
+    console.log "Rendering toolbar to", config, el 
+    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 )
+
+    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 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