luca 0.9.42 → 0.9.65

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,104 @@ 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:
+        "haha 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"  
+
+      afterRender: ()->
+        @getGamma().trigger("after:render:gamma")
+
+      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"
+          components:[
+            role: "gamma"
+            name: "haha"
+          ]
+        ]
+      ]
+
+    @container.render()
+
+  it "should give me all of the components", ->
+    names = _( @container.allChildren() ).pluck('name')
+    expect( names ).toEqual ['component_alpha','container_tester','beta_view','haha']
+
+  it "should drill down into nested components", ->
+    expect( @container.getBeta ).toBeDefined()
+    expect( @container.getBeta().name ).toEqual 'beta_view'
+
+  it "should observe the right rendering order", ->
+    expect( @container.getGamma() ).toHaveTriggered("after:render:gamma")
+    
+  it "should pick up events on nested components", ->
+    @container.getBeta().trigger("trigger:five")
+    expect( @container ).toHaveTriggered("five")
+
+  it "should recursively define role based getters", ->
+    expect( @container.getAlpha ).toBeDefined()
+    expect( @container.getBeta ).toBeDefined()
+    expect( @container.getGamma ).toBeDefined()
+
+  it "should define a getter", ->
+    expect( @container.getAlphaComponent ).toBeDefined()
+
+  it "should find a nested component by name", ->
+    expect( @container.findComponentByName('haha') ).toBeDefined()
+
+  it "should find the component by its name", ->
+    expect( @container.findComponentByName("beta_view") ).toBeDefined()
+
+  it "should find the component by its role", ->
+    expect( @container.findComponentByRole("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.getGamma().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/spec/modules/filterable_spec.coffee

@@ -0,0 +1,25 @@
+describe 'The Filterable Plugin', ->
+  describe 'Through the CollectionView', ->
+    beforeEach ->
+      @collection = new Luca.Collection [{name:"name"},{name:"filterable"}]
+
+      @view = new Luca.components.TableView
+        collection:@collection
+        columns:[reader:"name"] 
+
+    it 'should generate a Backbone.QueryCollection query payload', ->
+      expect( @view.getFilterState().toQuery() ).toBeDefined()
+
+    it "should have a toRemote method which merges params", ->
+      expect( @view.getFilterState().toRemote() ).toBeDefined()
+      
+    it 'should apply filter values', ->
+      @view.applyFilter(filter:"value")
+      expect( @view.getFilterState().toQuery().filter ).toEqual('value')
+
+    it 'should generate a Backbone.QueryCollection options payload', ->
+      expect( @view.getFilterState().toOptions() ).toBeDefined()
+
+    it "should trigger a refresh event on filter change", ->
+      @view.applyFilter(filter:"value")
+      expect( @view ).toHaveTriggered("refresh")

data/src/components/application.coffee

@@ -1,9 +1,9 @@
-# Luca.Application 
+# Luca.Application
 #
 # The Application class is the global state tracking mechanism
 # for your single page application, as well as the entry point.
 #
-# By default it contains a main controller which is a Luca.components.Controller instance. 
+# By default it contains a main controller which is a Luca.components.Controller instance.
 #
 # In a typical Luca application, the router will use the applications @navigate_to() method to switch
 # from page to page on the main controller, or any other controllers nested inside of it.
@@ -12,9 +12,10 @@
 #
 # Decoupling application control flow from the URL Fragment from Backbone.History and preventing
 # your components from directly caring about the URL Fragment, allows you to build applications as
-# isolated components which can run separately or nested inside of other applications.   
+# isolated components which can run separately or nested inside of other applications.
 
-startHistory = ()-> Backbone.history.start()
+Luca.util.startHistory = ()->
+  Backbone.history.start()
 
 _.def('Luca.Application').extends('Luca.containers.Viewport').with
   name: "MyApp"
@@ -26,18 +27,18 @@ _.def('Luca.Application').extends('Luca.containers.Viewport').with
   # the @defaultState property will be the default attributes
   defaultState: {}
 
-  # if autoBoot is set to true, the application will 
+  # if autoBoot is set to true, the application will
   # attempt to boot on document ready.
   autoBoot: false
 
-  # automatically starts the @router if it exists, 
-  # once the components for the application have 
+  # automatically starts the @router if it exists,
+  # once the components for the application have
   # been created.  Pass the event name you want to
   # listen for on this component before you start history
   autoStartHistory: "before:render"
 
   # we will create a collection manager singleton
-  # by default unless otherwise specified. 
+  # by default unless otherwise specified.
   useCollectionManager: true
 
   # to pass options to the collection manager, set the @collectionManager
@@ -46,7 +47,7 @@ _.def('Luca.Application').extends('Luca.containers.Viewport').with
 
   # by default we will use the standard collection manager which ships with
   # Luca.  If you would like to use your own extension of the collection manager
-  # just pass a reference to the class you would like to use. 
+  # just pass a reference to the class you would like to use.
   collectionManagerClass: "Luca.CollectionManager"
 
   # Luca plugin apps are apps which mount onto existing
@@ -61,7 +62,7 @@ _.def('Luca.Application').extends('Luca.containers.Viewport').with
   useController: true
 
   # Key Handler
-  # 
+  #
   # One responsibility of the application, since it is a viewport which monopolizes the entire screen
   # is to relay keypress events from the document, to whatever views are interested in responding to them.
   #
@@ -70,7 +71,7 @@ _.def('Luca.Application').extends('Luca.containers.Viewport').with
 
   # You can configure key events by specifying them by their name, as it exists in Luca.keyMap. For example:
   #
-  keyEvents: {} 
+  keyEvents: {}
 
   # keyEvents
   #   keyup: keyUpHandler
@@ -103,7 +104,7 @@ _.def('Luca.Application').extends('Luca.containers.Viewport').with
 
     Luca.Application.instances ||= {}
     Luca.Application.instances[ appName ] = app
-    
+
     Luca.containers.Viewport::initialize.apply @, arguments
 
     @state = new Luca.Model( @defaultState )
@@ -113,9 +114,9 @@ _.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 
+    # The Collection Manager is responsible
     @setupCollectionManager()
 
     # we will render when all of the various components
@@ -137,23 +138,23 @@ _.def('Luca.Application').extends('Luca.containers.Viewport').with
     #     forwardslash: "altSlashHandler"
     if @useKeyRouter is true
       console.log "The useKeyRouter property is being deprecated. switch to useKeyHandler instead"
-    
+
     @setupKeyHandler() if (@useKeyHandler is true or @useKeyRouter is true) and @keyEvents?
 
     # if the application is a plugin designed to modify the behavior
     # of another app, then don't claim ownership.  otherwise the most common
     # use-case is that there will be one application instance
     unless @plugin is true or alreadyRunning
-      Luca.getApplication = (name)=> 
+      Luca.getApplication = (name)=>
         return app unless name?
-        Luca.Application.instances[ name ] 
+        Luca.Application.instances[ name ]
 
     if @autoBoot
       if Luca.util.resolve(@name)
         throw "Attempting to override window.#{ @name } when it already exists"
 
       $ ->
-        window[ appName ] = app 
+        window[ appName ] = app
         app.boot()
 
   # @activeView() returns a reference to the instance of the view
@@ -161,14 +162,14 @@ _.def('Luca.Application').extends('Luca.containers.Viewport').with
   #
   # this will be whicever component is active on the controllers
   # nested within the main controller, if there are any, or the view
-  # itself which is active on the main controller. 
+  # itself which is active on the main controller.
   activeView: ()->
     if active = @activeSubSection()
       @view( active )
     else
       @view( @activeSection() )
 
-  # Returns the name of the active component on the main controller 
+  # Returns the name of the active component on the main controller
   activeSection: ()->
     @get("active_section")
 
@@ -216,7 +217,7 @@ _.def('Luca.Application').extends('Luca.containers.Viewport').with
     return @components[0] if @useController is true
     Luca.cache('main_controller')
 
-  # 
+  #
   keyHandler: (e)->
     return unless e and @keyEvents
 
@@ -253,9 +254,10 @@ _.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)       
+          @state.set(active_sub_section:current.name)
           app.trigger "sub:page:change"
 
   setupMainController: ()->
@@ -263,7 +265,7 @@ _.def('Luca.Application').extends('Luca.containers.Viewport').with
       definedComponents = @components || []
 
       @components = [
-        ctype: 'controller'
+        type: 'controller'
         name: "main_controller"
         components: definedComponents
       ]
@@ -271,23 +273,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
+    return if @collectionManager? and @collectionManager?.get?
 
-      if _.isObject(@collectionManager) and not _.isFunction( @collectionManager?.get )
-        collectionManagerOptions = @collectionManager
-        @collectionManager = undefined
+    if _.isString( @collectionManagerClass )
+      @collectionManagerClass = Luca.util.resolve( @collectionManagerClass )
 
-      if _.isString(@collectionManager)
-        collectionManagerOptions = 
-          name: @collectionManager
+    collectionManagerOptions = @collectionManagerOptions || {}
 
-      @collectionManager = Luca.CollectionManager.get?( collectionManagerOptions.name )
+    # 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
 
-      unless _.isFunction(@collectionManager?.get)
-        @collectionManager = new @collectionManagerClass( collectionManagerOptions )    
+    # 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 = @
@@ -301,7 +316,7 @@ _.def('Luca.Application').extends('Luca.containers.Viewport').with
     # you can control which by setting the @startHistoryOn property
     if @router and @autoStartHistory
       @autoStartHistory = "before:render" if @autoStartHistory is true
-      @defer(startHistory, false).until(@, @autoStartHistory)   
+      @defer( Luca.util.startHistory, false).until(@, @autoStartHistory)
 
   setupKeyHandler: ()->
     return unless @keyEvents
@@ -315,4 +330,3 @@ _.def('Luca.Application').extends('Luca.containers.Viewport').with
 
     for keyEvent in (@keypressEvents || ["keydown"])
       $( document ).on( keyEvent, handler )
-