luca 0.9.6 → 0.9.7

data/CHANGELOG

@@ -85,26 +85,26 @@
 0.9.1
   - Bugfix Release
 
-0.9.2 
+0.9.2
   - FormView has errorMessage, successMessage methods which use twitter bootstrap alerts as flash message
   - FormView toolbar accepts new options: true, both, bottom, or top
   - Luca.Collection has a property @remoteFiltering which makes applyFilter always use remote fetch
   - Bugfix in GridView collection change handler
   - Added Luca.isViewPrototype, Luca.isModelPrototype, Luca.isCollectionPrototype helpers
   - Added configuration option to control auto registration of components with the registry
-  - Added Luca.parentClass and Luca.inheritanceChain methods for inspecting a component or prototype  
+  - Added Luca.parentClass and Luca.inheritanceChain methods for inspecting a component or prototype
   - Changed single instance tracking mechanism on CollectionManager.  Will throw an error if more than one
     is created without specifying a name.
   - Added Luca.getCollectionManager() helper as an Alias for Luca.CollectionManager.get()
   - Luca.getApplication() and Luca.getCollectionManager() accept a name argument
   - Classes like Luca.Application and Luca.CollectionManager which normally are singletons
-    can have more than one instance if a unique name is given 
+    can have more than one instance if a unique name is given
 
 0.9.3
   - CardViews and Controllers set data attributes on their elements for the active card / page
   - Added convenience methods to container 'pluck', 'invoke'
   - Added methods to Controller for ease of autogenerating routes
-  - Added beforeInitialize hook on Luca.View 
+  - Added beforeInitialize hook on Luca.View
   - Luca.View can now automatically configure state machine models by passing `stateful:true`
     in your view definition.
   - Containers will respond to getter attributes set on their components, by defining a getter
@@ -118,9 +118,9 @@
   - adding a Luca.PageController component as an alias for Controller
 
 0.9.33
-  - added gridSpan property to Luca.View.  This will automatically add the span class for you to snap your view to the grid.  
+  - added gridSpan property to Luca.View.  This will automatically add the span class for you to snap your view to the grid.
     Accepts a number 0-12.
-  - fixed a bug in CardView.componentElements method with bodyClassName being present 
+  - fixed a bug in CardView.componentElements method with bodyClassName being present
   - Added LabelView component.  A form field which just displays a value.
 
 0.9.35
@@ -134,14 +134,14 @@
 
 0.9.4
   - Luca::Template can now configure its namespace, removing duplicate sprockets class
-  - Luca.Application triggers page:change and sub:page:change events  
+  - Luca.Application triggers page:change and sub:page:change events
   - Luca.Viewport gets enable / disable method for fluid and fullscreen mode
   - Add configurability to fullscreen behavior on viewport
 
 0.9.41
   - Changed asset pipeline payload so that luca-ui uses the index convention
 
-0.9.42 
+0.9.42
   - Added TableView component, which inherits from Luca.components.CollectionView
   - Expose ways of customizing Luca.View internals.
   - Added support for @template property on Luca.View. Behaves the same as @bodyTemplate
@@ -151,7 +151,7 @@
   - View mixins use _initializer methods
   - FilterableView mixin for CollectionView classes
   - Added Rails Generator for Luca.Application skeleton. ( thanks @nick-desteffen )
-  - Adds ability to pass a function reference as a component.  The container will call the function, in 
+  - Adds ability to pass a function reference as a component.  The container will call the function, in
     the context of the container, and use the returned object as the component definition template
   - Adds a defaults property to containers.  This will apply the values as defaults to each component.
   - Adds Luca.EventsExt an optional core extension which provides additional event binding sugar
@@ -160,20 +160,43 @@
   - bugfixes in CardView
 
 0.9.5
-  - Luca.Model gets a 'read' method which will a getter function, 
+  - Luca.Model gets a 'read' method which will a getter function,
     or get an attribute for the given property you are trying to 'read'
   - CollectionView is modifiable through several mixins:
     - Filterable
     - Paginatable
     - Loadmaskable
-  - Introduces component definition helpers: extends, 
-    behavesAs, triggers, defaultsTo which allow for a more 
+  - Introduces component definition helpers: extends,
+    behavesAs, triggers, defaultsTo which allow for a more
     "literate" component definiton style
   - View helpers moved into mixins:
     - StateModel
     - EnhancedProperties
     - CollectionEventBindings
-    - ApplicationEventBindings  
+    - ApplicationEventBindings
   - Changed syntax for @componentEvents configuration on Luca.core.Container.
-    - now accepts role, name, or getter method 
+    - now accepts role, name, or getter method
     - now accepts * for component, to bind to the same event on all components
+
+0.9.65
+  - Luca.core.Container components can now be configured with a @container property
+    which accepts any valid CSS selector so long as it is scoped within that container view's @$el.
+    Previously required an element with a specific ID which made it harder to build extendable components
+    with specific render targets
+
+0.9.66
+  - Luca.core.Container components can now be extended by subclasses by specifying an @extensions property.
+    @extensions work by applying the hash to the component in the same index'd position as that component
+    configuration in the superclass.
+  - Luca.components.CollectionView now has a @loadModels() method which resets the collection with the passed models.
+  - Added @componentMetaData() method which is going to replace the trickery done behind the scenes in Luca.extend
+  - Luca.config.autoApplyCssClassHierarchy if set to true, will add css class names to your luca components to make inheritance based styling easier.
+
+0.9.7
+  - Introduced publicInterface, publicConfiguration, privateInterface, and privateConfiguration as component registry methods.
+    These methods are intended to offer finer grain control over the component definition process for the purposes of building
+    our auto-generated documentation tool.
+  - Added Luca.concern support on Collection and Model
+  - Renaming 'mixin' and 'module' functionality to 'concern'
+  - Luca.concerns now follow the active support concern in spirit, with __included hooks, ClassMethods handling, etc
+  - Introducing an optional Concern for Luca.Model classes, called ModelPresenter.

data/lib/luca/rails/version.rb

@@ -1,6 +1,6 @@
 module Luca
   module Rails
-    VERSION = "0.9.6"
+    VERSION = "0.9.7"
   end
 end
 

data/spec/components/collection_view_spec.coffee

@@ -1,9 +1,9 @@
 describe 'The Collection View', ->
   beforeEach ->
     @collection = new Luca.Collection([
-      id: 1, attr: "value_one"
+      id: 1, attr: "value_one", filter: "value"
     ,
-      id: 2, attr: "value_two"
+      id: 2, attr: "value_two", filter: "value"
     ],
     model: Luca.Model)
 
@@ -12,9 +12,31 @@ describe 'The Collection View', ->
       itemClassName: "custom-class"
       itemProperty: 'attr'
       collection: @collection
+      filterable:
+        query:
+          filter: "value"
+        options:
+          sortBy: "filter"
 
     @view.render()
 
+  it "should provide access to the query", ->
+    expect( @view.getQuery() ).toBeDefined()
+
+  it "should provide access to the query options", ->
+    expect( @view.getQueryOptions() ).toBeDefined()
+
+  it "should combine filter and pagination in the options hash", ->
+    @view.setPage(5)
+    @view.applyFilter({filter:"value"},{sortBy:'filter'})
+
+    options = @view.getQueryOptions()
+    query = @view.getQuery()
+
+    expect( options.page ).toEqual 5
+    expect( options.sortBy ).toEqual 'filter'
+    expect( query.filter ).toEqual 'value'
+
   it "should render the attributes in the specified list elements", ->
     expect( @view.$html() ).toContain('value_one')
 

data/spec/concerns/dom_helpers_spec.coffee

@@ -0,0 +1,16 @@
+describe 'The DOM Helpers module', ->
+  describe "The Wrapping Helper", ->
+    it "should accept a space delimited list", ->
+      v = new Luca.View(wrapperClass: "class-one class-two")
+      expect( v.$el.parent().is(".class-one.class-two") ).toEqual(true)
+
+  describe "Auto Assigning Class Names", ->
+    it "should apply the class of the component all the way up its hierarchy", ->
+      c = new Luca.core.Container()
+      expect( c.$el.is(".luca-container") ).toBeTruthy()
+      expect( c.$el.is(".luca-panel") ).toBeTruthy()
+
+    it "should leave out backbone and luca view classes", ->
+      c = new Luca.core.Container()
+      expect( c.$el.is(".luca-view") ).not.toBeTruthy()
+      expect( c.$el.is(".backbone-view") ).not.toBeTruthy()

data/spec/concerns/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/spec/concerns/model_presenter_spec.coffee

@@ -0,0 +1,31 @@
+describe 'The Presenter Mixin', ->
+  presenterModel = Luca.register("Luca.models.PresenterModel").extends("Luca.Model")
+  presenterModel.mixesIn("ModelPresenter")
+  presenterModel.defines
+    randomProperty: "chocolate" 
+    fullName: ()->
+      @get("first_name") + ' ' + @get("last_name")
+    defaults: 
+      first_name: "Jonathan"
+      last_name: "Soeder"
+
+  it "should respond to presentAs", ->
+    expect( Luca.models.PresenterModel::presentAs ).toBeDefined()
+
+  it "should define the presenter class methods on the model class", ->
+    expect( Luca.models.PresenterModel.registerPresenter ).toBeDefined()
+
+  it "should define the presenter class methods on the model class", ->
+    expect( Luca.models.PresenterModel.getPresenter ).toBeDefined()
+
+  it "should register a presenter format", ->
+    Luca.models.PresenterModel.registerPresenter "names", ["first_name", "last_name", "fullName"]
+    expect( Luca.models.PresenterModel.getPresenter("names") ).toBeDefined()
+
+  it "should present a model in the desired format", ->
+    model = new Luca.models.PresenterModel()
+    presented = model.presentAs('names')
+    expect( _.isObject(presented) ).toEqual true
+    expect( presented ).toBeDefined()
+    expect( _( presented ).keys()... ).toEqual "first_name", "last_name", "fullName"
+    expect( presented.fullName ).toEqual 'Jonathan Soeder'

data/spec/concerns_spec.coffee

@@ -0,0 +1,88 @@
+describe 'The Concern System', ->
+
+  window.Luca ||= {}
+
+  Luca.concern.namespace 'Luca.test_concerns'
+
+  Luca.test_concerns =
+    CollectionMixin:
+      __initializer: ()->
+        @trigger "collection:mixin"
+    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
+
+  collection = Luca.register("Luca.components.MixinCollection")
+  collection.mixesIn "CollectionMixin"
+  collection.defines version: 2
+
+  model = Luca.register("Luca.components.MixinModel")
+  model.mixesIn "CollectionMixin"
+  model.defines version: 2
+
+  it "should work on models", ->
+    model = new Luca.components.MixinModel()
+    expect( model ).toHaveTriggered("collection:mixin")
+
+  it "should work on collections", ->
+    collection = new Luca.components.MixinCollection()
+    expect( collection ).toHaveTriggered("collection:mixin")
+
+  it "should work on views", ->
+    secondView = new Luca.components.SecondView
+    expect( secondView ).toHaveTriggered("second:mixin")
+
+  it "should omit methods prefixed with the double underscore", ->
+    sampleView = new Luca.components.FirstView
+    expect( sampleView.__privateMethod ).not.toBeDefined()
+
+
+  it "should extend the prototype with the concern definition", ->
+    sampleView = new Luca.components.FirstView
+    expect( sampleView.publicMethod ).toBeDefined()
+
+  it "should call the initializers up the prototype chain", ->
+    secondView = new Luca.components.SecondView
+    expect( secondView ).toHaveTriggered("first:mixin")
+    expect( secondView ).toHaveTriggered("second:mixin")
+
+  describe "Class Methods on the concern", ->
+    Luca.test_concerns.ExampleConcern = 
+      instanceMethod: ()-> "instanceMethod"
+      classMethods:
+        classMethod: ()-> "classMethod"
+
+    v = Luca.register("Luca.components.ClassMethodView").mixesIn("ExampleConcern")
+
+    v.defines(version:1)
+
+    it "should distinguish between instance methods and class methods", ->
+      value = Luca.components.ClassMethodView::instanceMethod.call(@)
+      expect( value ).toEqual 'instanceMethod'
+
+    it "should distinguish between instance methods and class methods", ->
+      value = Luca.components.ClassMethodView.classMethod.call(@)
+      expect( value ).toEqual 'classMethod'

data/spec/core/container_spec.coffee

@@ -3,6 +3,13 @@ describe 'The Luca Container', ->
     c = @container = new Luca.core.Container
       defaults:
         defaultProperty: 'it_works'
+      extensions:[
+        extension: 1
+      ,
+        extension: 2
+      ,
+        extension: 3
+      ]
       components:[
         name: "component_one"
         ctype: "view"
@@ -47,6 +54,10 @@ describe 'The Luca Container', ->
   it "should create a getter function on the container", ->
     expect( @container.getOne().name ).toEqual 'component_one'
 
+  it "should apply extensions to the components", ->
+    expect( @container.getRoleOne().extension ).toEqual 1
+    expect( @container.getRoleTwo().extension ).toEqual 2
+
   it "should apply default properties to components", ->
     defaults = @container.selectByAttribute('defaultProperty','it_works')
     custom = @container.selectByAttribute('defaultProperty','oh_yeah')
@@ -85,31 +96,70 @@ describe 'The Luca Container', ->
     @container.eachComponent (c)-> c.spy()
     expect( Luca.cache("component_four").spy ).toHaveBeenCalled()
 
+describe 'Component Inheritance and Customization', ->
+  it "should accept an array for extensions configuration and join on position/index", ->
+    container = new Luca.core.Container
+      extensions:[
+        undefined
+      ,
+        name: "custom_two"   
+      ]
+      components:[
+        role: "component_one"
+        name: "component_one"
+      ,
+        role: "component_two"
+        name: "component_two"
+      ]
+
+    container.render()    
+
+    expect( container.getComponentTwo().name ).toEqual "custom_two"
+
+  it "should accept an object for extensions configuration and join using role", ->
+    container = new Luca.core.Container
+      extensions:
+        component_one:
+          name: "custom_one"
+      components:[
+        role: "component_one"
+        name: "component_one"
+      ,
+        role: "component_two"
+        name: "component_two"
+      ]
+
+    container.render()    
+
+    expect( container.getComponentOne().name ).toEqual "custom_one"
 
 describe 'Component Event Binding', ->
   beforeEach ->
     @container = new Luca.core.Container
       componentEvents:
-        "component_alpha trigger:one"       : "one"
+        "haha trigger:one"                  : "one"
         "alpha trigger:two"                 : "two"
         "getAlphaComponent trigger:three"   : "three"
         "* trigger:four"                    : "four"
         "beta trigger:five"                 : "five"
 
       one: ()->
-        @trigger "one" 
+        @trigger "one"
 
       two: ()->
-        @trigger "two" 
+        @trigger "two"
 
       three: ()->
-        @trigger "three" 
+        @trigger "three"
 
       four: ()->
-        @trigger "four"  
+        @trigger "four"
 
       five: ()->
-        @trigger "five"  
+        @trigger "five"
+
+      afterRender: ()->
+        @getGamma().trigger("after:render:gamma")
 
       registerComponentEvents: ()->
         Luca.core.Container::registerComponentEvents.apply(@, arguments)
@@ -124,6 +174,10 @@ describe 'Component Event Binding', ->
         components:[
           name: "beta_view"
           role: "beta"
+          components:[
+            role: "gamma"
+            name: "haha"
+          ]
         ]
       ]
 
@@ -131,27 +185,35 @@ describe 'Component Event Binding', ->
 
   it "should give me all of the components", ->
     names = _( @container.allChildren() ).pluck('name')
-    expect( names ).toEqual ['component_alpha','container_tester','beta_view']
+    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 define a role based getter", ->
+  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 the component by its role", ->
-    expect( @container.findComponentByRole("alpha") ).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('component_alpha') ).toBeDefined()
+    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()
@@ -161,7 +223,7 @@ describe 'Component Event Binding', ->
     expect( @container ).toHaveTriggered("four")
 
   it "should accept component events with a component name", ->
-    @container.getAlphaComponent().trigger "trigger:one"
+    @container.getGamma().trigger "trigger:one"
     expect(@container).toHaveTriggered("one")
 
   it "should accept component events with a component role", ->

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

@@ -10,10 +10,4 @@ describe 'The Component Definition System', ->
     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/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"
+
+
+