luca 0.9.7 → 0.9.8

data/app/assets/javascripts/luca/components/multi_collection_view.coffee

@@ -0,0 +1,92 @@
+multiView = Luca.register     "Luca.components.MultiCollectionView"
+
+# The CollectionMultiView is a collection view with multiple renderings
+# of the list.  ( e.g. Icons, Table, List ).  It works by maintaining
+# a current view, and rendering that view.  It refreshes the views
+# whenever they are activated. 
+#
+# The MultiView allows you to share one collection, filter, pagination setup
+# but render multiple versions of a model.  To do this, you  are expected to
+# define one or more objects in the @views property of the component.
+
+# Example:
+#   multiView = new Luca.components.MultiCollectionView
+#     collection: "my_collection"
+#     paginatable:
+#       page: 1
+#       limit: 20
+#     views:[
+#       type:           "table"
+#       columns:[
+#         header: "Header"
+#         reader: "attribute"
+#       ]
+#     ]
+multiView.extends           "Luca.containers.CardView"
+
+multiView.mixesIn           "QueryCollectionBindings", 
+                            "LoadMaskable",
+                            "Filterable",
+                            "Paginatable",
+                            "Sortable"
+
+multiView.triggers          "before:refresh",
+                            "after:refresh",
+                            "refresh",
+                            "empty:results"
+
+multiView.private
+  stateful:
+    activeView: 0
+
+  initialize: (@options={})->
+    @components ||= @views
+
+    for view in @components    
+      Luca.components.MultiCollectionView.validateComponent( view ) 
+
+    Luca.containers.CardView::initialize.apply(@, arguments) 
+
+    @on "data:refresh", @refresh, @
+    @on "after:card:switch", @refresh, @
+    @on "after:components", Luca.components.MultiCollectionView.propagateCollectionComponents, @
+
+  relayAfterRefresh: (models,query,options)->
+    @trigger "after:refresh", models, query, options
+
+  refresh: ()->
+    @activeComponent()?.refresh()
+
+multiView.classMethods
+  propagateCollectionComponents: ()->
+    container = @
+
+    # in the multi view will share the same
+    # collection, filter state, pagination options, etc
+    for component in @components
+
+      component.on "after:refresh", (models,query,options)=> 
+        @debug "collection member after refresh"
+        @trigger("after:refresh",models,query,options)
+
+      _.extend component, 
+        collection: container.getCollection() 
+        getQuery: _.bind(container.getQuery, container)
+        getQueryOptions: _.bind(container.getQueryOptions, container)
+
+      if container.prepareQuery?
+        _.extend component,
+          prepareQuery: _.bind(container.prepareQuery, container)
+
+  validateComponent: (component)->
+    type = (component.type || component.ctype)
+
+    return if  type is "collection" or 
+               type is "collection_view" or
+               type is "table" or
+               type is "table_view" 
+
+    throw "The MultiCollectionView expects to contain multiple collection views" 
+
+multiView.defines
+  version: 3

data/{src → app/assets/javascripts/luca}/components/nav_bar.coffee

@@ -1,4 +1,8 @@
-_.def("Luca.components.NavBar").extends("Luca.View").with
+navBar = Luca.register "Luca.components.NavBar"
+
+navBar.extends         "Luca.View"
+
+navBar.defines
   fixed: true
   position: 'top'
   className: 'navbar'

data/app/assets/javascripts/luca/components/page_controller.coffee

@@ -0,0 +1,7 @@
+#_.def("Luca.PageController").extends("Luca.components.Controller").with
+pageController = Luca.register "Luca.PageController"
+
+pageController.extends          "Luca.components.Controller"
+
+pageController.defines
+  version: 2

data/{src → app/assets/javascripts/luca}/components/pagination_control.coffee

@@ -7,6 +7,9 @@ paginationControl.defines
 
   stateful: true
 
+  stateChangeEvents:
+    "numberOfPages" : "onPageCountChange"
+
   autoBindEventHandlers: true
 
   events:
@@ -14,25 +17,22 @@ paginationControl.defines
     "click a.next"              : "nextPage"
     "click a.prev"              : "previousPage"
 
-  afterInitialize: ()->
-    _.bindAll @, "updateWithPageCount"
-
-    @state?.on "change", (state, numberOfPages)=>
-      @updateWithPageCount( state.get('numberOfPages') )
+  onPageCountChange: ()->
+    @updateWithPageCount( @get('numberOfPages') )
 
   limit: ()->
-    parseInt (@state.get('limit') || @collection?.length)
+    parseInt (@get('limit') || @collection?.length)
 
   page: ()->
-    parseInt (@state.get('page') || 1)
+    parseInt (@get('page') || 1)
 
   nextPage: ()->
     return unless @nextEnabled()
-    @state.set('page', @page() + 1 )
+    @set('page', @page() + 1 )
 
   previousPage: ()->
     return unless @previousEnabled()
-    @state.set('page', @page() - 1 )
+    @set('page', @page() - 1 )
 
   selectPage: (e)->
     me = my = @$( e.target )
@@ -44,10 +44,10 @@ paginationControl.defines
     @setPage( my.data('page-number') )
 
   setPage: (page=1,options={})->
-    @state.set('page', page, options)
+    @set('page', page, options)
 
   setLimit: (limit=1,options={})->
-    @state.set('limit', limit, options)
+    @set('limit', limit, options)
 
   pageButtonContainer: ()->
     @$ '.group'
@@ -100,5 +100,5 @@ paginationControl.defines
     parseInt @collection?.length || 0
 
   itemsPerPage: (value, options={})->
-    @state.set("limit", value, options) if value?
-    parseInt @state.get("limit")
+    @set("limit", value, options) if value?
+    parseInt @get("limit")

data/{src → app/assets/javascripts/luca}/components/router.coffee

@@ -1,4 +1,7 @@
-_.def("Luca.Router").extends("Backbone.Router").with
+#_.def("Luca.Router").extends("Backbone.Router").with
+router = Luca.register  "Luca.Router"
+router.extends          "Backbone.Router"
+router.defines
   routes:
     "" : "default"
 
@@ -14,6 +17,8 @@ _.def("Luca.Router").extends("Backbone.Router").with
       @bind "route:#{ route_id }", ()=>
         @trigger.apply @, ["change:navigation", route_id  ].concat( _( arguments ).flatten() )
 
+    Backbone.Router.initialize?.apply(@, arguments)
+
   #### Router Functions
 
   # Intercept calls to Backbone.Router.navigate so that we can at least

data/app/assets/javascripts/luca/components/table_view.coffee

@@ -0,0 +1,89 @@
+tableView = Luca.register     "Luca.components.TableView"
+tableView.extends             "Luca.components.CollectionView"
+
+tableView.publicConfiguration
+  widths: []
+  columns:[]
+  emptyText: "There are no results to display"
+
+tableView.privateConfiguration
+  additionalClassNames: "table"
+  tagName: "table"
+  bodyTemplate: "table_view"
+  bodyTagName: "tbody"
+  bodyClassName: "table-body"
+  stateful: true
+  itemTagName: "tr"
+  observeChanges: true
+
+tableView.privateMethods
+  eachColumn: (fn, scope=@)->
+    index = 0
+    for col in @columns  
+      fn.call(scope, col, index++, @)
+
+  itemRenderer: (item, model)->
+    Luca.components.TableView.rowRenderer.call(@, item, model)
+
+  initialize: (@options={})->
+    Luca.components.CollectionView::initialize.apply(@, arguments)
+
+    index = 0
+    @columns = for column in @columns
+      if width = @widths[ index ]
+        column.width = width
+
+      if _.isString(column)
+        column = reader: column
+
+      if !column.header?
+        column.header = _.str.titleize(_.str.humanize(column.reader))
+
+      index++
+      column
+
+    @defer ()=> 
+      Luca.components.TableView.renderHeader.call(@, @columns, @$('thead') )
+    .until("after:render")
+
+tableView.classMethods
+  renderHeader : (columns, targetElement)->
+    index = 0
+
+    @$( targetElement ).append("<tr></tr>")
+
+    for column in columns
+      attrs = "data-col-index": index++
+
+      if column.sortable
+        attrs.class = "sortable-toggle"
+        attrs["data-sortable-sort-by"] = column.sortBy || column.sortable
+        attrs["data-sortable-order"] = column.order
+
+      content = column.header 
+      content = "<a class='link'>#{ column.header }</a>" if column.sortable
+
+      @$(targetElement).append( Backbone.View::make "th", attrs, content )
+
+
+    index = 0
+
+    for column in columns when column.width?
+      th = @$("th[data-col-index='#{ index++ }']",targetElement)
+      th.css('width', column.width)
+
+
+  rowRenderer: (item, model, index)->
+    colIndex = 0
+    for columnConfig in @columns
+      Luca.components.TableView.renderColumn.call(@, columnConfig, item, model, colIndex++) 
+
+  renderColumn : (column, item, model, index)->
+    cellValue = model.read( column.reader )
+
+    if _.isFunction( column.renderer )
+      cellValue = column.renderer.call @, cellValue, model, column 
+
+    Backbone.View::make("td", {"data-col-index":index}, cellValue)
+
+tableView.register()

data/{src → app/assets/javascripts/luca}/concerns/application_event_bindings.coffee

@@ -16,4 +16,4 @@ Luca.concerns.ApplicationEventBindings =
       unless _.isFunction(handler)
         throw "Error registering application event #{ eventTrigger } on #{ @name || @cid }"
 
-      app.on(eventTrigger, handler)
+      app.on(eventTrigger, handler, @)

data/app/assets/javascripts/luca/concerns/collection_event_bindings.coffee

@@ -0,0 +1,44 @@
+Luca.concerns.CollectionEventBindings = 
+  __initializer: ()->
+    Luca.concerns.CollectionEventBindings.__setup.call(@)
+
+    unless @collectionEventBindingsSetup is true
+      if Luca.isBackboneCollection(@collection)
+        @collection.on "reset",         relayAs("collection:reset"), @
+        @collection.on "add",           relayAs("collection:add"), @
+        @collection.on "remove",        relayAs("collection:remove"), @
+        @collection.on "change",        relayAs("collection:change"), @
+        @collection.on "before:fetch",  relayAs("collection:fetch"), @
+        
+      @collectionEventBindingsSetup = true
+
+  __setup: ()->
+    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, @)
+      catch e
+        console.log "Error Binding To Collection in registerCollectionEvents", @
+        throw e
+
+
+relayAs = (eventName)->
+  (args...)->
+    args.unshift(eventName)
+    @trigger.apply(@, args)

data/{src → app/assets/javascripts/luca}/concerns/deferrable.coffee

@@ -8,8 +8,7 @@ Luca.concerns.Deferrable =
     if _.isString( @collection ) and collectionManager = Luca.CollectionManager?.get()
       @collection = collectionManager.getOrCreate(@collection)
 
-    # if there is already an instantiated backbone collection don't do anything
-    unless @collection and _.isFunction( @collection.fetch ) and _.isFunction( @collection.reset )
+    if _.isObject(@collection) and not Luca.isBackboneCollection(@collection) 
       @collection = new Luca.Collection( @collection.initial_set, @collection )
     
     if @collection?.deferrable_trigger

data/{src/plugins → app/assets/javascripts/luca/concerns}/development_tool_helpers.coffee

@@ -1,4 +1,4 @@
-Luca.DevelopmentToolHelpers = 
+Luca.concerns.DevelopmentToolHelpers = 
   refreshCode: ()->
     view = @
 

data/{src → app/assets/javascripts/luca}/concerns/dom_helpers.coffee

@@ -7,16 +7,16 @@ Luca.concerns.DomHelpers =
     if _.isString additionalClasses
       additionalClasses = additionalClasses.split(" ")
 
-    if @gridSpan
-      additionalClasses.push "span#{ @gridSpan }"
+    if span = @gridSpan || @span
+      additionalClasses.push "span#{ span }"
 
-    if @gridOffset
-      additionalClasses.push "offset#{ @gridOffset }"
+    if offset = @gridOffset || @offset
+      additionalClasses.push "offset#{ offset }"
 
-    if @gridRowFluid
+    if @gridRowFluid || @rowFluid
       additionalClasses.push "row-fluid"
 
-    if @gridRow
+    if @gridRow || @row
       additionalClasses.push "row"
 
     return unless additionalClasses?
@@ -40,7 +40,10 @@ Luca.concerns.DomHelpers =
     @$el.parent('[data-wrapper="true"]')  
 
   $template: (template, variables={})->
-    @$el.html( Luca.template(template,variables) )
+    try 
+      @$el.html( Luca.template(template,variables) )
+    catch e
+      console.log "Error in $template: #{ template } #{ @identifier?() ? @name || @cid }"
 
   $html: (content)->
     @$el.html( content )

data/app/assets/javascripts/luca/concerns/filterable.coffee

@@ -0,0 +1,104 @@
+Luca.concerns.Filterable = 
+  classMethods:
+    prepare: ()->
+      filter = _.clone( @getQuery() )
+      options = _.clone( @getQueryOptions() )
+
+      prepared = @prepareRemoteFilter(filter, options)
+
+      @debug "Preparing filterable call", prepared, @isRemote()
+
+      if @isRemote()  
+        @collection.applyFilter(prepared, remote: true)
+      else
+        @trigger "data:refresh" 
+  
+  __included: (component, module)->
+    _.extend(Luca.Collection::, __filters:{})
+
+  __initializer: (component, module)->
+    if @filterable is false
+      return
+
+    @filterable = {} if @filterable is true
+
+    # TEMP HACK
+    unless Luca.isBackboneCollection(@collection)
+      @collection = Luca.CollectionManager.get?()?.getOrCreate(@collection)
+       
+    unless Luca.isBackboneCollection(@collection)
+      @debug "Skipping Filterable due to no collection being present on #{ @name || @cid }"
+      @debug "Collection", @collection
+      return
+
+    @getCollection ||= ()-> @collection
+
+    filter = @getFilterState()
+
+    @querySources ||= []
+    @optionsSources ||= []
+    @query ||= {}
+    @queryOptions ||= {}
+
+    @querySources.push ((options={})=> @getFilterState().toQuery())
+    @optionsSources.push ((options={})=> @getFilterState().toOptions())
+
+    filter.on "change", ()=> @trigger "filter:change"
+
+    @on "filter:change", Luca.concerns.Filterable.classMethods.prepare, @
+
+    module
+
+  prepareRemoteFilter: (filter={}, options={})->
+    filter[ Luca.config.apiLimitParameter ] = options.limit if options.limit?
+    filter[ Luca.config.apiPageParameter ] = options.page if options.page?
+    filter[ Luca.config.apiSortByParameter ] = options.sortBy if options.sortBy?
+    
+    filter
+
+  isRemote: ()->
+    return true if @getQueryOptions().remote is true
+    return true if @remoteFilterFallback is true and @getCollection()?.length is 0
+
+  getFilterState: ()->
+    {options,query} = config = @filterable || {}
+
+    if !_.isEmpty(config) and (_.isEmpty(query) and _.isEmpty(options))
+      _.extend(options, _( config ).pluck('sortBy','page','limit') )
+
+    @collection.__filters[ @cid ] ||= new FilterModel
+      query: query || {}
+      options: options || {}
+
+  setSortBy: (sortBy, options={})->
+    @getFilterState().setOption('sortBy', sortBy, options)
+
+  applyFilter: (query={}, options={})->
+    options = _.defaults(options, @getQueryOptions())
+    query = _.defaults(query, @getQuery())
+    @getFilterState().clear(silent:false)
+    @getFilterState().set({query,options}, options)
+
+class FilterModel extends Backbone.Model
+  defaults:
+    options: {}
+    query: {}
+    
+  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: ()->
+    _.clone(@toJSON().options)
+
+  toQuery: ()->
+    _.clone(@toJSON().query)
+
+  toRemote: ()->
+    Luca.concerns.Filterable.prepareRemoteFilter.call(@, @toQuery(), @toOptions())

data/{src → app/assets/javascripts/luca}/concerns/loadmaskable.coffee

@@ -1,18 +1,24 @@
 Luca.concerns.LoadMaskable = 
   __initializer: ()->
-    return unless @loadMask is true
+    return if @loadMask is false or not @loadMask?
 
     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 (@loadmaskEnableEvent || "enable:loadmask"), @applyLoadMask, @
-      @on (@loadmaskDisableEvent || "disable:loadmask"), @applyLoadMask, @
+      @loadMask = 
+        enableEvent: "enable:loadmask"
+        disableEvent: "disable:loadmask"
+
+    @on "collection:fetch", ()=> @trigger "enable:loadmask"
+    @on "collection:reset", ()=> @trigger "disable:loadmask"
+
+    @on "after:render", ()->
+      @$el.addClass('with-mask')
+      if @$('.load-mask').length is 0 and @loadMaskTemplate?
+        @loadMaskTarget().prepend Luca.template(@loadMaskTemplate, @)
+        @$('.load-mask').hide()
+    , @
+
+    @on(@loadMask.enableEvent, @applyLoadMask, @)
+    @on(@loadMask.disableEvent, @applyLoadMask, @)
 
   showLoadMask: ()->
     @trigger("enable:loadmask")

data/{src → app/assets/javascripts/luca}/concerns/paginatable.coffee

@@ -1,6 +1,6 @@
 Luca.concerns.Paginatable = 
   paginatorViewClass: 'Luca.components.PaginationControl'
-  paginationSelector: ".toolbar.bottom"
+  paginationSelector: ".toolbar.bottom.pagination-container"
 
   __included: ()->
     _.extend(Luca.Collection::, __paginators: {})
@@ -9,9 +9,8 @@ Luca.concerns.Paginatable =
     if @paginatable is false
       return
 
-    # TEMP HACK
-    unless Luca.isBackboneCollection(@collection)
-      @collection = Luca.CollectionManager.get?()?.getOrCreate(@collection)
+    if _.isNumber(@paginatable) or _.isString(@paginatable)
+      @paginatable = limit: parseInt(@paginatable), page: 1
 
     unless Luca.isBackboneCollection(@collection)
       @debug "Skipping Paginatable due to no collection being present on #{ @name || @cid }"
@@ -20,10 +19,7 @@ Luca.concerns.Paginatable =
 
     _.bindAll @, "paginationControl", "pager"
 
-    @getCollection ||= ()-> 
-      @collection
-
-    collection = @getCollection()
+    collection = (@getCollection ||= ()-> @collection)()
 
     paginationState = @getPaginationState()
 
@@ -34,13 +30,9 @@ Luca.concerns.Paginatable =
       options = _( paginationState.toJSON() ).pick('limit','page','sortBy')
       _.extend(options, pager: @pager)
 
-    paginationState.on "change:page", (state)=> 
-      if @isRemote() 
-        filter = _.extend(@toQuery(), @toQueryOptions()) 
-        @collection.applyFilter(filter, remote: true)
-      else
-        @trigger "refresh" 
+    paginationState.on "change:page", ()=> @trigger "pagination:change"
 
+    @on "pagination:change",  Luca.concerns.Filterable.classMethods.prepare, @
     @on "before:render", @renderPaginationControl, @
 
   pager: (numberOfPages, models)->

data/app/assets/javascripts/luca/concerns/query_collection_bindings.coffee

@@ -0,0 +1,46 @@
+Luca.concerns.QueryCollectionBindings = 
+  getCollection: ()->
+    @collection
+
+  loadModels: (models=[], options={})->
+    @getCollection()?.reset(models, options)
+
+  applyQuery: (query={},queryOptions={})->
+    @query = query
+    @queryOptions = queryOptions
+    @refresh()
+    @
+
+  # Private: returns the query that is applied to the underlying collection.
+  # accepts the same options as Luca.Collection.query's initial query option.
+  getQuery: (options={})-> 
+    query = @query ||= {}
+
+    for querySource in _( @querySources || [] ).compact()
+      query = _.extend(query, (querySource(options)||{}) ) 
+          
+    Luca.util.readAll(query)
+
+  # Private: returns the query that is applied to the underlying collection.
+  # accepts the same options as Luca.Collection.query's initial query option.
+  getQueryOptions: (options={})-> 
+    queryOptions = @queryOptions ||= {}
+
+    for optionSource in _( @optionsSources || [] ).compact()
+      queryOptions = _.extend(queryOptions, (optionSource(options)||{}) ) 
+
+    queryOptions
+  # Private: returns the models to be rendered.  If the underlying collection
+  # responds to @query() then it will use that interface. 
+  getModels: (query,options)->
+    if @collection?.query
+      query ||= @getQuery()
+      options ||= @getQueryOptions()
+      options.prepare ||= @prepareQuery
+
+      # TODO
+      # Need to write specs for this  
+      @collection.query(query, options)
+    else
+      @collection.models
+