luca 0.9.4 → 0.9.6

data/spec/components/collection_view_spec.coffee

@@ -0,0 +1,37 @@
+describe 'The Collection View', ->
+  beforeEach ->
+    @collection = new Luca.Collection([
+      id: 1, attr: "value_one"
+    ,
+      id: 2, attr: "value_two"
+    ],
+    model: Luca.Model)
+
+    @view = new Luca.components.CollectionView
+      itemTagName: "li"
+      itemClassName: "custom-class"
+      itemProperty: 'attr'
+      collection: @collection
+
+    @view.render()
+
+  it "should render the attributes in the specified list elements", ->
+    expect( @view.$html() ).toContain('value_one')
+
+  it "should render each of the attributes", ->
+    expect( @view.$('li.custom-class').length ).toEqual 2
+
+  it "should locate a dom element by luca model id", ->
+    expect( @view.locateItemElement(2).html() ).toContain('value_two')
+
+  it "should refresh the view when a model is added", ->
+    @view.collection.add(attr:"value_three",id:3)
+    expect( @view ).toHaveTriggered('after:refresh')
+
+  it "should refresh the view when a model is removed", ->
+    @view.collection.remove( @view.collection.at(0) )
+    expect( @view ).toHaveTriggered('after:refresh')
+
+
+
+

data/spec/components/multi_collection_view_spec.coffee

@@ -0,0 +1,5 @@
+describe 'The Collection Multi View component', ->
+  it "should share a single collection among multiple collection views", ->
+  it "should toggle visibility of one or more views", ->
+  it "should share pagination state across the multiple views", ->
+  it "should share filter state across the multiple views", ->

data/spec/components/table_view_spec.coffee

@@ -0,0 +1,17 @@
+describe 'The Table View', ->
+  beforeEach ->
+    @tableView = new Luca.components.TableView  
+      collection: new Luca.Collection
+      columns:[
+        "column_one"
+        "column_two"
+      ]
+
+    $('body').append( @tableView.render() )
+
+  it 'should accept strings for column config', ->
+    expect( @tableView.columns[0].reader ).toEqual("column_one")
+
+  it 'should automatically determine a missing header config', ->
+    expect( @tableView.columns[0].header ).toBeDefined()
+

data/spec/core/container_spec.coffee

@@ -1,13 +1,18 @@
 describe 'The Luca Container', ->
   beforeEach ->
-    @container = new Luca.core.Container
+    c = @container = new Luca.core.Container
+      defaults:
+        defaultProperty: 'it_works'
       components:[
         name: "component_one"
         ctype: "view"
+        defaultProperty: "oh_yeah"
         bodyTemplate: ()-> "markup for component one"
         id: "c1"
         value: 1
+        getter: "getOne"
         spy: sinon.spy()
+        role: "role_one"
       ,
         name: "component_two"
         ctype: "view"
@@ -15,6 +20,8 @@ describe 'The Luca Container', ->
         id: "c2"
         value: 0
         spy: sinon.spy()
+        role: "role_two"
+        getter: "getComponentTwo"
       ,
         name: "component_three"
         ctype: "container"
@@ -29,6 +36,23 @@ describe 'The Luca Container', ->
         ]
       ]
 
+    @container.render()
+
+  it "should create getter methods on the for components with roles", ->
+    expect( @container.getRoleTwo ).toBeDefined()
+
+  it "should create getter methods on the for components with roles", ->
+    expect( @container.getRoleTwo().name ).toEqual 'component_two'
+
+  it "should create a getter function on the container", ->
+    expect( @container.getOne().name ).toEqual 'component_one'
+
+  it "should apply default properties to components", ->
+    defaults = @container.selectByAttribute('defaultProperty','it_works')
+    custom = @container.selectByAttribute('defaultProperty','oh_yeah')
+    expect( defaults.length ).toEqual(2)
+    expect( custom.length ).toEqual(1)
+
   it "should trigger after initialize", ->
     expect( @container ).toHaveTriggered "after:initialize"
 
@@ -47,7 +71,7 @@ describe 'The Luca Container', ->
     expect( html ).toContain "markup for component four"
 
   it "should select all components matching a key/value combo", ->
-    components = @container.select("value",1)
+    components = @container.selectByAttribute("value",1)
     expect( components.length ).toEqual 2
 
   it "should run a function on each component", ->
@@ -61,6 +85,89 @@ describe 'The Luca Container', ->
     @container.eachComponent (c)-> c.spy()
     expect( Luca.cache("component_four").spy ).toHaveBeenCalled()
 
-  it "should be able to find a component by name", ->
-    expect( @container.findComponentByName("component_one") ).toBeDefined()
-    expect( @container.findComponentByName("undefined") ).not.toBeDefined()
+
+describe 'Component Event Binding', ->
+  beforeEach ->
+    @container = new Luca.core.Container
+      componentEvents:
+        "component_alpha trigger:one"       : "one"
+        "alpha trigger:two"                 : "two"
+        "getAlphaComponent trigger:three"   : "three"
+        "* trigger:four"                    : "four"
+        "beta trigger:five"                 : "five"
+
+      one: ()->
+        @trigger "one" 
+
+      two: ()->
+        @trigger "two" 
+
+      three: ()->
+        @trigger "three" 
+
+      four: ()->
+        @trigger "four"  
+
+      five: ()->
+        @trigger "five"  
+
+      registerComponentEvents: ()->
+        Luca.core.Container::registerComponentEvents.apply(@, arguments)
+
+      components:[
+        name: "component_alpha"
+        role: "alpha"
+        getter: "getAlphaComponent"
+      ,
+        name: "container_tester"
+        type: "container"
+        components:[
+          name: "beta_view"
+          role: "beta"
+        ]
+      ]
+
+    @container.render()
+
+  it "should give me all of the components", ->
+    names = _( @container.allChildren() ).pluck('name')
+    expect( names ).toEqual ['component_alpha','container_tester','beta_view']
+
+  it "should drill down into nested components", ->
+    expect( @container.getBeta ).toBeDefined()
+    expect( @container.getBeta().name ).toEqual 'beta_view'
+
+  it "should pick up events on nested components", ->
+    @container.getBeta().trigger("trigger:five")
+    expect( @container ).toHaveTriggered("five")
+
+  it "should define a role based getter", ->
+    expect( @container.getAlpha ).toBeDefined()
+
+  it "should define a getter", ->
+    expect( @container.getAlphaComponent ).toBeDefined()
+
+  it "should find the component by its role", ->
+    expect( @container.findComponentByRole("alpha") ).toBeDefined()
+
+  it "should find the component by its name", ->
+    expect( @container.findComponentByName('component_alpha') ).toBeDefined()
+
+  it "should find the component by its getter", ->
+    expect( @container.findComponentByGetter('getAlphaComponent') ).toBeDefined()
+
+  it "should accept wildcard for component", ->
+    @container.getAlphaComponent().trigger "trigger:four"
+    expect( @container ).toHaveTriggered("four")
+
+  it "should accept component events with a component name", ->
+    @container.getAlphaComponent().trigger "trigger:one"
+    expect(@container).toHaveTriggered("one")
+
+  it "should accept component events with a component role", ->
+    @container.getAlphaComponent().trigger "trigger:two"
+    expect(@container).toHaveTriggered("two")
+
+  it "should accept component events with a component getter", ->
+    @container.getAlphaComponent().trigger "trigger:three"
+    expect(@container).toHaveTriggered("three")

data/spec/core/model_spec.coffee

@@ -14,15 +14,15 @@ describe "Luca.Model with computed attribute", ->
     computed:
       fullName: ['firstName', 'lastName']
 
-  it "should have it undefined if dependences are not set", ->
+  it "should be undefined if dependences are not set", ->
     model = new App.models.Sample
     expect(model.get("fullName")).toEqual(undefined)
 
-  it "should have it undefined if callback function is not present", ->
+  it "should be undefined if callback function is not present", ->
     model = new App.models.SampleWithoutCallback
     expect(model.get("fullName")).toEqual(undefined)
 
-  it "should not call it's callback if dependences are not set", ->
+  it "should not call the callback if dependences are not set", ->
     model = new App.models.Sample
     spy   = sinon.spy(model, "fullName")
     expect( spy.called ).toEqual(false)
@@ -48,3 +48,21 @@ describe "Luca.Model with computed attribute", ->
   it "should have it set on constructor if dependencies are supplied", ->
     model = new App.models.Sample({firstName:"Nickolay", lastName: "Schwarz"})
     expect(model.get("fullName")).toEqual('Nickolay Schwarz')
+
+
+describe 'The Read Method', ->
+
+  ModelClass = Luca.Model.extend
+    defaults:
+      attribute: "attribute"
+    reader: ()-> 
+      "reader"
+
+  it "should read an attribute", ->
+    model = new ModelClass()
+    expect( model.read('attribute') ).toEqual "attribute"
+
+  it "should read functions", ->
+    model = new ModelClass()
+    expect( model.read('attribute') ).toEqual "attribute"
+    expect( model.read('reader') ).toEqual 'reader'

data/spec/define_spec.coffee

@@ -0,0 +1,19 @@
+describe 'The Component Definition System', ->
+  beforeEach ->
+    Luca.components.SampleComponentDefinition = undefined
+
+  it "should define a component", ->
+    Luca.register("Luca.components.SampleComponentDefinition").defines(version: 1)
+    expect( Luca.isComponentPrototype(Luca.components.SampleComponentDefinition) ).toEqual true
+
+  it "should default to Luca.View for the extends portion", ->
+    Luca.register("Luca.components.SampleComponentDefinition").defines(version: 1)
+    expect( Luca.parentClasses(Luca.components.SampleComponentDefinition) ).toContain 'Luca.View'
+
+  it "should track the parent classes", ->
+    Luca.register("Luca.components.SampleComponentDefinition").defines(version: 1)
+    expect( Luca.parentClasses(Luca.components.SampleComponentDefinition) ).toEqual ['Luca.View','Backbone.View'] 
+
+  xit "should defer component extension until dependencies are defined", ->
+
+

data/spec/mixin_spec.coffee

@@ -0,0 +1,49 @@
+describe 'The Mixin System', ->
+
+  window.Luca ||= {}
+
+  Luca.mixin.namespace 'Luca.test_modules'
+
+  Luca.test_modules =
+    SecondMixin:
+      __included: ()->
+        window.secondMixinIncluded = true
+      __initializer: ()->
+        @trigger "second:mixin"
+    FirstMixin:
+      __initializer: ()->
+        @trigger "first:mixin"
+      __privateMethod: ()->
+        true
+      publicMethod: ()-> 
+        true
+
+  sampleView = Luca.register('Luca.components.FirstView')
+
+  sampleView.mixesIn 'FirstMixin'
+
+  sampleView.defines
+    sampleMethod: ()->
+      "sample"
+
+  secondView = Luca.register("Luca.components.SecondView")
+  secondView.extends 'Luca.components.FirstView'
+  secondView.mixesIn 'SecondMixin'
+  secondView.defines
+    version: 2
+
+  it "should omit the private methods defined on the mixin", ->
+    sampleView = new Luca.components.FirstView
+    expect( sampleView.__privateMethod ).not.toBeDefined()
+
+  it "should extend the prototype with the mixins normal methods", ->
+    sampleView = new Luca.components.FirstView
+    expect( sampleView.publicMethod ).toBeDefined()
+
+  it "should call the initializer for that module on the instance", ->
+    secondView = new Luca.components.SecondView
+    expect( secondView ).toHaveTriggered("second:mixin")
+
+  it "should call the initializers up the prototype chain", ->
+    secondView = new Luca.components.SecondView
+    expect( secondView ).toHaveTriggered("first:mixin")

data/src/components/application.coffee

@@ -113,7 +113,7 @@ _.def('Luca.Application').extends('Luca.containers.Viewport').with
     # method which delegates to the controller, and allows you to navigate
     # to a given page, or component, by its name.  The controller integrates
     # with the state machine of the application
-    @setupMainController()
+    @setupMainController() if @useController is true
 
     # The Collection Manager is responsible 
     @setupCollectionManager()
@@ -253,7 +253,8 @@ _.def('Luca.Application').extends('Luca.containers.Viewport').with
     # any time the card switches on one of the sub controllers
     # then we should track the active sub section on the global state chart
     @getMainController()?.each (component)=>
-      if component.ctype.match(/controller$/)
+      type = component.type || component.type
+      if type.match(/controller$/)
         component.bind "after:card:switch", (previous,current)=>
           @state.set(active_sub_section:current.name)       
           app.trigger "sub:page:change"
@@ -263,7 +264,7 @@ _.def('Luca.Application').extends('Luca.containers.Viewport').with
       definedComponents = @components || []
 
       @components = [
-        ctype: 'controller'
+        type: 'controller'
         name: "main_controller"
         components: definedComponents
       ]
@@ -271,23 +272,36 @@ _.def('Luca.Application').extends('Luca.containers.Viewport').with
       @defer( @setupControllerBindings, false ).until("after:components")
 
   setupCollectionManager: ()->
-    if @useCollectionManager is true
-      @collectionManagerClass = Luca.util.resolve( @collectionManagerClass ) if _.isString( @collectionManagerClass )
+    return unless @useCollectionManager is true
 
-      collectionManagerOptions = @collectionManagerOptions
-
-      if _.isObject(@collectionManager) and not _.isFunction( @collectionManager?.get )
-        collectionManagerOptions = @collectionManager
-        @collectionManager = undefined
-
-      if _.isString(@collectionManager)
-        collectionManagerOptions = 
-          name: @collectionManager
-
-      @collectionManager = Luca.CollectionManager.get?( collectionManagerOptions.name )
-
-      unless _.isFunction(@collectionManager?.get)
-        @collectionManager = new @collectionManagerClass( collectionManagerOptions )    
+    return if @collectionManager? and @collectionManager?.get?
+    
+    if _.isString( @collectionManagerClass )
+      @collectionManagerClass = Luca.util.resolve( @collectionManagerClass ) 
+
+    collectionManagerOptions = @collectionManagerOptions || {}
+
+    # if the collectionManager property is present, and it
+    # isn't a reference to a collection manager instance, then
+    # it is being used as a configuration hash for when we do create
+    # the collection manager. so let's stash it.
+    if _.isObject(@collectionManager) and not _.isFunction( @collectionManager?.get )
+      collectionManagerOptions = @collectionManager
+      @collectionManager = undefined
+
+    # if the collection manager property is a string, then it is a
+    # reference to a name of a collection manager to use.  so let's
+    # stash it 
+    if _.isString(@collectionManager)
+      collectionManagerOptions = 
+        name: @collectionManager
+
+    # let's try and get the collection manager by name if we can
+    @collectionManager = Luca.CollectionManager.get?( collectionManagerOptions.name )
+
+    # if we can't, then we will have to create one ourselves
+    unless _.isFunction(@collectionManager?.get)
+      @collectionManager = new @collectionManagerClass( collectionManagerOptions )    
 
   setupRouter: ()->
     app = @

data/src/components/collection_view.coffee

@@ -1,15 +1,33 @@
-# Public: The CollectionView renders a collection of models into a list of items.
+collectionView = Luca.define      "Luca.components.CollectionView"
+# The CollectionView facilitates the rendering of a Collection
+# of models into a group of many rendered templates
 # 
-# Examples
+# Example:
 #
-#   _.def('App.ListView').extends('Luca.components.CollectionView').with
-#     collection: new App.SampleCollection()
-#     itemTemplate: "list_view_item"
-#     loadMask: true
+#   new Luca.components.CollectionView 
+#     itemTemplate: "template_name"
+#     collection:   "collection_class_name"
+#     pagination:
+#       page: 1
+#       limit: 15
+#     filterable:
+#       query:
+#         default: 'value'     
 #
+collectionView.extends            "Luca.components.Panel"
 
-_.def("Luca.components.CollectionView").extends("Luca.components.Panel").with
-  tagName: "div"
+collectionView.behavesAs          "LoadMaskable", 
+                                  "Filterable", 
+                                  "Paginatable"
+
+collectionView.triggers           "before:refresh",
+                                  "after:refresh",
+                                  "refresh",
+                                  "empty:results"
+
+collectionView.defaults
+
+  tagName: "ol"
 
   className: "luca-ui-collection-view"
 
@@ -25,16 +43,13 @@ _.def("Luca.components.CollectionView").extends("Luca.components.Panel").with
 
   itemClassName: 'collection-item'
 
-  hooks:[
-    "empty:results"
-  ]
-  
   initialize: (@options={})->
     _.extend(@, @options)
 
     _.bindAll @, "refresh"
 
     unless @collection? or @options.collection
+      console.log "Error on initialize of collection view", @
       throw "Collection Views must specify a collection"
 
     unless @itemTemplate? || @itemRenderer? || @itemProperty?
@@ -45,56 +60,111 @@ _.def("Luca.components.CollectionView").extends("Luca.components.Panel").with
     if _.isString(@collection) and Luca.CollectionManager.get()
       @collection = Luca.CollectionManager.get().getOrCreate(@collection)
 
-    if Luca.isBackboneCollection(@collection)
+    unless Luca.isBackboneCollection(@collection)
+      throw "Collection Views must have a valid backbone collection"
+
       @collection.on "before:fetch", ()=>
-        @trigger "enable:loadmask" if @loadMask is true
+        @trigger "enable:loadmask"
         
       @collection.bind "reset", ()=>
-        @trigger "disable:loadmask" if @loadMask is true
         @refresh()
+        @trigger "disable:loadmask"
 
-      @collection.bind "add", @refresh
-      @collection.bind "remove", @refresh
-    else
-      throw "Collection Views must have a valid backbone collection"
+      @collection.bind "remove", ()=>
+        @refresh()
+
+      @collection.bind "add", ()=>
+        @refresh()
+
+      if @observeChanges is true
+        @collection.on "change", @refreshModel, @
 
-    if @collection.length > 0
-      @refresh()
+    unless @autoRefreshOnModelsPresent is false
+      @defer ()=> 
+        @refresh() if @collection.length > 0
+      .until("after:render")
 
-  attributesForItem: (item)->
-    _.extend {}, class: @itemClassName, "data-index": item.index
+    @on "collection:change", @refresh, @
+
+  attributesForItem: (item, model)->
+    _.extend {}, class: @itemClassName, "data-index": item.index, "data-model-id": item.model.get('id')
 
   contentForItem: (item={})->
     if @itemTemplate? and templateFn = Luca.template(@itemTemplate)
-      content = templateFn.call(@, item)
+      return content = templateFn.call(@, item)
 
     if @itemRenderer? and _.isFunction( @itemRenderer )
-      content = @itemRenderer.call(@, item, item.model, item.index)
+      return content = @itemRenderer.call(@, item, item.model, item.index)
 
-    if @itemProperty
-      content = item.model.get(@itemProperty) || item.model[ @itemProperty ]
-      content = content() if _.isFunction(content)
+    if @itemProperty and item.model?
+      return content = item.model.read( @itemProperty )
 
-    content
+    ""
 
   makeItem: (model, index)->
     item = if @prepareItem? then @prepareItem.call(@, model, index) else (model:model, index: index)
-    make(@itemTagName, @attributesForItem(item), @contentForItem(item))
-
-  getModels: ()->
-    if @collection?.query and (@filter || @filterOptions)
-      @collection.query(@filter, @filterOptions)
+    attributes = @attributesForItem(item, model) 
+    content = @contentForItem(item)
+    # TEMP
+    # Figure out why calls to make are failing with an unexpected string error
+    try
+      make(@itemTagName, attributes, content)
+    catch e
+      console.log "Error generating DOM element for CollectionView", @, model, index
+      #no op
+
+  getCollection: ()->
+    @collection
+
+  # Private: returns the query that is applied to the underlying collection.
+  # accepts the same options as Luca.Collection.query's initial query option.
+  getQuery: ()-> 
+    @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: ()-> 
+    @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()
+      
+      @collection.query(query, options)
     else
       @collection.models
 
-  refresh: ()->
+  locateItemElement: (id)->
+    @$(".#{ @itemClassName }[data-model-id='#{ id }']")
+
+  refreshModel: (model)->
+    index = @collection.indexOf( model )
+    @locateItemElement(model.get('id')).empty().append( @contentForItem({model,index}, model) )
+    @trigger("model:refreshed", index, model)
+
+  refresh: (query,options)->
+    query ||= @getQuery()
+    options ||= @getQueryOptions()
+
     @$bodyEl().empty()
+    models = @getModels(query, options)
+
+    @trigger("before:refresh", models, query, options)
 
-    if @getModels().length is 0
+    if models.length is 0
       @trigger("empty:results")
 
-    _( @getModels() ).each (model, index)=>
-      @$append( @makeItem(model, index) )
+    index = 0
+
+    for model in models
+      @$append @makeItem(model, index++)
+
+    @trigger("after:refresh", models, query, options)
+
+    @
 
   registerEvent: (domEvent, selector, handler)->
     if !handler? and _.isFunction(selector)
@@ -111,4 +181,5 @@ _.def("Luca.components.CollectionView").extends("Luca.components.Panel").with
 
 # Private Helpers
 
+
 make = Luca.View::make