luca 0.9.65 → 0.9.76

data/spec/core/field_spec.coffee

@@ -0,0 +1,4 @@
+describe 'The core Field class', ->
+  it "should be set to isField", ->
+    field = new Luca.core.Field()
+    expect( field.isField ).toEqual true

data/spec/core/model_spec.coffee

@@ -50,13 +50,14 @@ describe "Luca.Model with computed attribute", ->
     expect(model.get("fullName")).toEqual('Nickolay Schwarz')
 
 
-describe 'The Read Method', ->
 
+describe 'The Read Method', ->
   ModelClass = Luca.Model.extend
     defaults:
       attribute: "attribute"
     reader: ()-> 
       "reader"
+    property: true
 
   it "should read an attribute", ->
     model = new ModelClass()
@@ -66,3 +67,7 @@ describe 'The Read Method', ->
     model = new ModelClass()
     expect( model.read('attribute') ).toEqual "attribute"
     expect( model.read('reader') ).toEqual 'reader'
+
+  it "should read model object attributes as a fallback", ->
+    model = new ModelClass()
+    expect( model.read('property') ).toEqual true

data/spec/define_spec.coffee

@@ -1,19 +1,116 @@
 describe 'The Component Definition System', ->
   beforeEach ->
-    Luca.components.SampleComponentDefinition = undefined
+    unfinished = Luca.register 'Luca.components.UnfinishedDefinition'
+
+    sample = Luca.register  'Luca.components.SampleComponentDefinition'
+
+    sample.classMethods
+      classMethod: ()-> "classMethod"
+
+    sample.contains
+      name: "component_one"
+    ,
+      name: "component_two"
+
+    sample.classConfiguration
+      classAttribute: "classAttribute"
+
+    sample.afterDefinition( sinon.spy() )
+
+    sample.publicInterface
+      publicAttribute: "publicAttribute"
+      publicMethod: ()-> "publicMethod"
+
+    sample.privateInterface
+      privateAttribute: "privateAttribute"
+      privateMethod: ()-> "privateMethod"
+
+    sample.publicConfiguration
+      publicProperty: "publicProperty"
+
+    sample.privateConfiguration
+      privateProperty: "privateProperty"
+
+    sample.register()
+
+  it "should find a definition ", ->
+    definition = Luca.define.findDefinition('Luca.components.UnfinishedDefinition')
+    expect( Luca.components.UnfinishedDefinition ).not.toBeDefined()
+    expect( definition ).toBeDefined()
+
+  it "should find a component definition through the Luca() helper", ->
+    definition = Luca("Luca.components.SampleComponentDefinition")
+    expect( definition.extend ).toBeDefined()
+    expect( definition.register ).not.toBeDefined()
+
+  it "should find an incomplete definition through the Luca() helper", ->
+    definition = Luca("Luca.components.UnfinishedDefinition")
+    expect( definition ).toBeDefined()
+    expect( definition.register ).toBeDefined()
+
+  # I did this to make the definition not require a single method
+  # to be called at the end every time, if it is more readable to leave it off.
+  it "should know if a definition is 'open'", ->
+    definition = Luca("Luca.components.UnfinishedDefinition")
+    expect( definition.isOpen() ).toBeTruthy()
+
+  it "should close any open definitions", ->
+    Luca.define.close()
+    expect( Luca.components.UnfinishedDefinition ).toBeDefined()  
+    expect( Luca.define.incomplete().length ).toEqual 0
 
   it "should define a component", ->
-    Luca.register("Luca.components.SampleComponentDefinition").defines(version: 1)
     expect( Luca.isComponentPrototype(Luca.components.SampleComponentDefinition) ).toEqual true
 
+  it "should add everything defined for the prototype", ->
+    for attribute in ["publicMethod","publicProperty","publicAttribute","privateAttribute","privateMethod","privateProperty"]
+      expect( Luca.components.SampleComponentDefinition.prototype[attribute] ).toBeDefined()
+
   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 define class methods ", ->  
+    test = Luca.components.SampleComponentDefinition.classMethod()
+    expect( test ).toEqual 'classMethod'
+
+  it "should inherit class methods when extending", ->
+    Luca.register("Luca.components.ExtendedSampleComponent").extends("Luca.components.SampleComponentDefinition").register()
+    test = Luca.components.ExtendedSampleComponent.classMethod()
+    expect( test ).toEqual('classMethod')
+
+  it "should define class configuration ", ->  
+    test = Luca.components.SampleComponentDefinition.classAttribute
+    expect( test ).toEqual 'classAttribute'
+
+  describe 'The Component MetaData', ->
+    beforeEach ->
+      @metaData = Luca.registry.getMetaDataFor('Luca.components.SampleComponentDefinition')
+
+    it "should provide access to component meta data", ->
+      meta = Luca.components.SampleComponentDefinition::componentMetaData()
+      expect( meta ).toEqual( @metaData )
+
+    it "should know the public interface", ->
+      expect( @metaData.publicAttributes() ).toContain('publicProperty','publicMethod','publicAttribute')
+
+    it "should know the public methods", ->
+      expect( @metaData.publicMethods() ).toContain('publicMethod')
+      expect( @metaData.publicMethods() ).not.toContain('publicAttribute')
+
+    it "should know the private interface", ->
+      expect( @metaData.privateAttributes() ).toContain('privateProperty','privateMethod','privateAttribute')
 
-  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'] 
+    it "should know the private methods", ->
+      expect( @metaData.privateMethods() ).toContain('privateMethod')
+      expect( @metaData.privateMethods() ).not.toContain('privateAttribute')
 
-  xit "should defer component extension until dependencies are defined", ->
+    it "should know the class methods", ->
+      expect( @metaData.classMethods() ).toContain("classMethod")
 
+    it "should fire the afterDefinition hook on the component class", ->
+      expect( Luca.components.SampleComponentDefinition.afterDefinition ).toHaveBeenCalled() 
 
+    describe 'Component Configuration Validations', ->
+      xit "should support specifying which values are required"
+      xit "should validate required values are present"
+      xit "should validate required values match certain expectations around data type"

data/spec/framework_spec.coffee

@@ -8,7 +8,7 @@ describe "The Luca Framework", ->
     expect(Luca).toBeDefined()
 
   it "should enable bootstrap by default", ->
-    expect(Luca.enableBootstrap).toBeTruthy()
+    expect(Luca.config.enableBoostrap).toBeTruthy()
 
   it "should have classes in the registry", ->
     expect( Luca.registry.classes ).toBeDefined()
@@ -113,3 +113,32 @@ describe "Luca Component Definition", ->
   it "should allow me to set the namespace before the definition", ->
     Luca.util.namespace("Luca.View")
     expect( Luca.util.namespace() ).toEqual Luca.View
+
+describe 'Application Space Initialization', ->
+  window.SampleLucaApplication = undefined
+
+  Luca.initialize("SampleLucaApplication", configOption: true)
+
+  it "should create the namespace", ->
+    expect( SampleLucaApplication ).toBeDefined()
+
+  it "should override luca config settings", ->
+    expect( Luca.config.configOption ).toEqual true
+    
+  it "should create a helper function", ->
+    expect( SampleLucaApplication("Luca.View") ).toEqual( Luca.View )    
+
+  it "should create the container for views", ->
+    expect( SampleLucaApplication.views ).toBeDefined()
+
+  it "should create the container for models", ->
+    expect( SampleLucaApplication.models ).toBeDefined()
+
+  it "should create the container for collections", ->
+    expect( SampleLucaApplication.collections ).toBeDefined()
+
+  it "should set the collection namespace", ->
+    namespace = Luca.util.read( Luca.Collection.namespace )
+    expect( namespace ).toEqual SampleLucaApplication.collections
+
+

data/spec/util_spec.coffee

@@ -0,0 +1,24 @@
+describe 'The Luca Utilities', ->
+  describe "Converting from component class to css class", ->
+    it "should produce a css class from the component class name", ->
+      component = "Luca.core.Container"
+      cssClass = Luca.util.toCssClass(component)
+      expect( cssClass ).toEqual 'luca-core-container'
+
+    it "should produce a css class from the component class name", ->
+      component = "Luca.components.MultiCollectionView"
+      cssClass = Luca.util.toCssClass(component)
+      expect( cssClass ).toEqual 'luca-components-multi-collection-view'
+
+    it "should produce a css class from the component class name", ->
+      component = "Luca.View"
+      cssClass = Luca.util.toCssClass(component)
+      expect( cssClass ).toEqual 'luca-view'
+
+    it "should exclude parts", ->
+      component = "Luca.components.MultiCollectionView"
+      cssClass = Luca.util.toCssClass(component, 'components')
+      expect( cssClass ).toEqual "luca-multi-collection-view"
+
+
+

data/src/components/application.coffee

@@ -2,22 +2,13 @@
 #
 # 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.
-#
-# 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.
-#
-# You would control flow when the controller fires activation events on the nested view components inside of it.
-#
-# 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.
+application = Luca.register       "Luca.Application"
+application.extends               "Luca.containers.Viewport"
 
-Luca.util.startHistory = ()->
-  Backbone.history.start()
+application.triggers              "controller:change",
+                                  "action:change"
 
-_.def('Luca.Application').extends('Luca.containers.Viewport').with
+application.publicInterface
   name: "MyApp"
 
   # The Application uses a Backbone.Model as a state machine, which
@@ -91,7 +82,7 @@ _.def('Luca.Application').extends('Luca.containers.Viewport').with
   # will get wrapped by the main controller unless you
   # set useController = false
   components:[
-    ctype: 'template'
+    type: 'template'
     name: 'welcome'
     template: 'sample/welcome'
     templateContainer: "Luca.templates"
@@ -102,8 +93,7 @@ _.def('Luca.Application').extends('Luca.containers.Viewport').with
     appName         = @name
     alreadyRunning  = Luca.getApplication?()
 
-    Luca.Application.instances ||= {}
-    Luca.Application.instances[ appName ] = app
+    Luca.Application.registerInstance(@)
 
     Luca.containers.Viewport::initialize.apply @, arguments
 
@@ -213,11 +203,7 @@ _.def('Luca.Application').extends('Luca.containers.Viewport').with
   navigate_to: (component_name, callback)->
     @getMainController().navigate_to(component_name, callback)
 
-  getMainController: ()->
-    return @components[0] if @useController is true
-    Luca.cache('main_controller')
-
-  #
+application.privateInterface
   keyHandler: (e)->
     return unless e and @keyEvents
 
@@ -249,7 +235,7 @@ _.def('Luca.Application').extends('Luca.containers.Viewport').with
     # the active card on the global state chart
     @getMainController()?.bind "after:card:switch", (previous,current)=>
       @state.set(active_section:current.name)
-      app.trigger "page:change"
+      app.trigger "controller:change"
 
     # any time the card switches on one of the sub controllers
     # then we should track the active sub section on the global state chart
@@ -258,7 +244,7 @@ _.def('Luca.Application').extends('Luca.containers.Viewport').with
       if type.match(/controller$/)
         component.bind "after:card:switch", (previous,current)=>
           @state.set(active_sub_section:current.name)
-          app.trigger "sub:page:change"
+          app.trigger "action:change"
 
   setupMainController: ()->
     if @useController is true
@@ -267,8 +253,11 @@ _.def('Luca.Application').extends('Luca.containers.Viewport').with
       @components = [
         type: 'controller'
         name: "main_controller"
+        role: "main_controller"
         components: definedComponents
       ]
+      
+      @getMainController = ()=> @findComponentByRole('main_controller')
 
       @defer( @setupControllerBindings, false ).until("after:components")
 
@@ -316,7 +305,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( Luca.util.startHistory, false).until(@, @autoStartHistory)
+      @defer( Luca.Application.startHistory, false).until(@, @autoStartHistory)
 
   setupKeyHandler: ()->
     return unless @keyEvents
@@ -330,3 +319,51 @@ _.def('Luca.Application').extends('Luca.containers.Viewport').with
 
     for keyEvent in (@keypressEvents || ["keydown"])
       $( document ).on( keyEvent, handler )
+
+application.classInterface
+  instances: {}
+  registerInstance: (app)->
+    Luca.Application.instances[ app.name ] = app
+  routeTo: (pages...)->
+    last = _( pages ).last()
+    first = _( pages ).first()
+
+    callback = undefined    
+    specifiedAction = undefined
+
+    routeHelper = (args...)->
+      path = @app || Luca()
+      index = 0
+
+      if pages.length is 1 and target = Luca(first)
+        pages = target.controllerPath()
+
+      for page in pages when _.isString(page)
+        nextItem = pages[++index]
+        action = undefined
+
+        if _.isFunction(nextItem)
+          action = nextItem
+        else if _.isObject(nextItem) and nextItem.action?
+          action = nextItem.action
+        else if page is last and routeHandler = Luca(last)?.routeHandler
+          action = Luca.util.read(routeHandler)
+
+        if _.isString( action )
+          callback = ()-> 
+            @[ action ].apply(@, args)
+
+        if _.isFunction( action )
+          callback = nextItem
+
+        path = path.navigate_to(page, callback)
+
+      routeHelper.action = (action)->
+        pages.push(action: action)
+
+      return routeHelper
+
+  startHistory: ()->
+    Backbone.history.start()
+
+application.register()

data/src/components/base_toolbar.coffee

@@ -1,15 +1,17 @@
 _.def('Luca.components.Toolbar').extends('Luca.core.Container').with
 
+toolbar = Luca.register     "Luca.components.Toolbar"
+toolbar.extends             "Luca.core.Container"
+
+toolbar.defines
   className: 'luca-ui-toolbar toolbar'
 
   position: 'bottom'
 
-  initialize: (@options={})->
-    Luca.core.Container::initialize.apply @, arguments
-
   prepareComponents: ()->
     _( @components ).each (component)=>
       component.container = @$el
 
   render: ()->
-    $(@container).append(@el)
+    $(@container).append(@el)
+    @

data/src/components/collection_loader_view.coffee

@@ -3,8 +3,10 @@
 # if you want to. Default implementation uses twitter bootstrap modal and
 # progress bar (http://twitter.github.com/bootstrap/). You template
 # should contain `progress`, `bar` and `message` classes
-_.def('Luca.components.CollectionLoaderView').extends('Luca.components.Template').with
+loaderView = Luca.register        "Luca.components.CollectionLoaderView"
+loaderView.extends                "Luca.View"
 
+loaderView.defines
   className: 'luca-ui-collection-loader-view'
 
   template: "components/collection_loader_view"

data/src/components/collection_view.coffee

@@ -1,4 +1,4 @@
-collectionView = Luca.define      "Luca.components.CollectionView"
+collectionView = Luca.register      "Luca.components.CollectionView"
 # The CollectionView facilitates the rendering of a Collection
 # of models into a group of many rendered templates
 # 
@@ -16,7 +16,8 @@ collectionView = Luca.define      "Luca.components.CollectionView"
 #
 collectionView.extends            "Luca.components.Panel"
 
-collectionView.behavesAs          "LoadMaskable", 
+collectionView.mixesIn            "QueryCollectionBindings", 
+                                  "LoadMaskable", 
                                   "Filterable", 
                                   "Paginatable"
 
@@ -25,31 +26,36 @@ collectionView.triggers           "before:refresh",
                                   "refresh",
                                   "empty:results"
 
-collectionView.defaults
-
+# IDEA:
+# 
+# For validation of component configuration,
+# we could define a convention like:
+#
+# collectionView.validatesConfigurationWith
+#   requiresValidCollectionAt: "collection"
+#   requiresPresenceOf: 
+#     either: ["itemTemplate", "itemRenderer", "itemProperty"]
+#
+#
+collectionView.publicConfiguration
   tagName: "ol"
-
-  className: "luca-ui-collection-view"
-
   bodyClassName: "collection-ui-panel"
-
-  # A collection view can pass a model through to a template
-  itemTemplate: undefined
-
-  # A collection view can pass a model through a function which should return a string
-  itemRenderer: undefined
-
   itemTagName: 'li'
-
   itemClassName: 'collection-item'
+  itemTemplate: undefined
+  itemRenderer: undefined
+  itemProperty: undefined
 
-
+collectionView.defines
   initialize: (@options={})->
     _.extend(@, @options)
-
     _.bindAll @, "refresh"
 
-
+    # IDEA:
+    #
+    # This type of code could be moved into a re-usable concern
+    # which higher order components can mixin to make it easier
+    # to extend them, instantiate them, etc.
     unless @collection? or @options.collection
       console.log "Error on initialize of collection view", @
       throw "Collection Views must specify a collection"
@@ -67,29 +73,24 @@ collectionView.defaults
       console.log "Missing Collection on #{ @name || @cid }", @, @collection
       throw "Collection Views must have a valid backbone collection"
 
-      @collection.on "before:fetch", ()=>
-        @trigger "enable:loadmask"
-        
-      @collection.bind "reset", ()=>
-        @refresh()
-        @trigger "disable:loadmask"
+    @collection.on "before:fetch", ()=>
+      @trigger "enable:loadmask"
+      
+    @collection.bind "reset", ()=>
+      @refresh()
+      @trigger "disable:loadmask"
 
-      @collection.bind "remove", ()=>
-        @refresh()
+    @collection.bind "remove", ()=>
+      @refresh()
 
-      @collection.bind "add", ()=>
-        @refresh()
+    @collection.bind "add", ()=>
+      @refresh()
 
-      if @observeChanges is true
-        @collection.on "change", @refreshModel, @
+    if @observeChanges is true
+      @collection.on "change", @refreshModel, @
 
     Luca.components.Panel::initialize.apply(@, arguments)
 
-    unless @autoRefreshOnModelsPresent is false
-      @defer ()=> 
-        @refresh() if @collection.length > 0
-      .until("after:render")
-
     @on "refresh", @refresh, @
 
   attributesForItem: (item, model)->
@@ -119,44 +120,6 @@ collectionView.defaults
       console.log "Error generating DOM element for CollectionView", @, model, index
       #no op
 
-  getCollection: ()->
-    @collection
-
-  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: ()-> 
-    query = @query ||= {}
-    for querySource in _( @querySources || [] ).compact()
-      query = _.extend(query, (querySource()||{}) ) 
-    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 ||= {}
-
-    for optionSource in _( @optionsSources || [] ).compact()
-      options = _.extend(options, (optionSource()||{}) ) 
-
-    options
-
-  # 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
-
   locateItemElement: (id)->
     @$(".#{ @itemClassName }[data-model-id='#{ id }']")