luca 0.9.65 → 0.9.76

data/CHANGELOG

@@ -184,3 +184,33 @@
     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.
+  - The callback argument passed to CardView activate, now gets called in the context of the activated component
+
+0.9.75
+  - Component registration is now beautifully readable and self documenting,
+    and flexible.  Minimally only requires one call to Luca.register().  This allows you to be as descriptive as you like when defining a component, and does not require you to call any definition methods which do not make literary sense in your component description. 
+  - Component definition now supports specifying class methods.
+  - Luca.initialize('Namespace') will setup a complete namespace for 
+    your application, and give you a Namespace() method which works similar
+    to the Luca() helper.
+  - Added Luca.config.modelBootrstrap and Luca.config.baseParams as pointers
+    to either properties, or methods, which can be used to configure Luca.Collection behavior
+  - Luca.onReady is now the preferred way of launching the application.
+  - Added Luca.Application.routeTo, Luca.Application.controller 
+    route building helpers

data/Gemfile

@@ -15,4 +15,5 @@ group :test, :development do
   gem 'rb-fsevent', '>= 0.9.1'
   gem 'pry'
   gem 'guard-jasmine'
+  gem 'jasmine'
 end

data/Gemfile.lock

@@ -1,6 +1,7 @@
 GEM
   remote: http://rubygems.org/
   specs:
+    addressable (2.3.2)
     childprocess (0.3.1)
       ffi (~> 1.0.6)
     coderay (0.9.8)
@@ -8,6 +9,7 @@ GEM
       coffee-script-source
       execjs
     coffee-script-source (1.2.0)
+    diff-lcs (1.1.3)
     ejs (1.0.0)
     execjs (1.2.13)
       multi_json (~> 1.0)
@@ -28,6 +30,15 @@ GEM
     haml (3.1.4)
     hike (1.2.1)
     i18n (0.6.0)
+    jasmine (1.3.0)
+      jasmine-core (>= 1.3.0)
+      rack (~> 1.0)
+      rspec (>= 1.3.1)
+      selenium-webdriver (>= 0.1.3)
+    jasmine-core (1.3.0)
+    libwebsocket (0.1.7.1)
+      addressable
+      websocket
     method_source (0.6.7)
       ruby_parser (>= 2.3.1)
     multi_json (1.0.4)
@@ -41,9 +52,23 @@ GEM
       rack
     rake (0.9.2.2)
     rb-fsevent (0.9.1)
+    rspec (2.12.0)
+      rspec-core (~> 2.12.0)
+      rspec-expectations (~> 2.12.0)
+      rspec-mocks (~> 2.12.0)
+    rspec-core (2.12.0)
+    rspec-expectations (2.12.0)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.12.0)
     ruby_parser (2.3.1)
       sexp_processor (~> 3.0)
+    rubyzip (0.9.9)
     sass (3.1.12)
+    selenium-webdriver (2.26.0)
+      childprocess (>= 0.2.5)
+      libwebsocket (~> 0.1.3)
+      multi_json (~> 1.0)
+      rubyzip
     sexp_processor (3.0.9)
     sinatra (1.3.1)
       rack (~> 1.3, >= 1.3.4)
@@ -59,6 +84,7 @@ GEM
     uglifier (1.2.0)
       execjs (>= 0.3.0)
       multi_json (>= 1.0.2)
+    websocket (1.0.4)
 
 PLATFORMS
   ruby
@@ -70,6 +96,7 @@ DEPENDENCIES
   guard-jasmine
   guard-sprockets2
   haml
+  jasmine
   pry
   rake
   rb-fsevent (>= 0.9.1)

data/lib/luca/rails/version.rb

@@ -1,6 +1,6 @@
 module Luca
   module Rails
-    VERSION = "0.9.65"
+    VERSION = "0.9.76"
   end
 end
 

data/spec/components/controller_spec.coffee

@@ -0,0 +1,58 @@
+describe 'The Controller Component', ->
+  beforeEach ->
+    controller = Luca.register  'Luca.components.SpecController'
+    controller.extends          'Luca.components.Controller' 
+    controller.defines
+      name: "spec_controller"
+      defaultCard: 'one'
+      rootComponent: true
+      components:[
+        name: "one"
+        type: "controller"
+        components:[
+          name: "alpha"
+        ,
+          name: "bravo"
+        ]
+      ,
+        name: "two"
+        type: "controller"
+        components:[
+          name: "charlie"
+        ,
+          name: "delta"
+        ]
+      ,
+        name: "three"
+        type: "controller"
+        components:[
+          name: "echo"
+        ]
+      ,
+        name: "four"
+        type: "view"
+      ]
+
+    @controller = new Luca.components.SpecController().render()
+
+  it "should track the names of its pages", ->
+    names = @controller.sectionNames()
+    expect( names... ).toEqual 'one', 'two', 'three', 'four'
+
+  it "should track the names of its controllers", ->
+    names = _( @controller.controllers() ).pluck 'name'
+    expect( names... ).toEqual 'one', 'two', 'three'
+
+  it "should be stateful", ->
+    expect( @controller.state ).toBeDefined()
+
+  it "should track the active page", -> 
+    @controller.navigate_to("two")
+    expect( @controller.activePage() ).toEqual 'two'
+
+  it "should define a controllerPath method on each page", ->
+    expect( @controller.activeComponent().controllerPath ).toBeDefined()
+
+  it "should know the controller path", ->
+    path = @controller.activeComponent().controllerPath()
+    expect( path... ).toEqual "spec_controller", "one"

data/spec/components/form_view_spec.coffee

@@ -47,6 +47,10 @@ describe 'The Form View', ->
   it "should create a form", ->
     expect( @form ).toBeDefined()
 
+  it "should have access to all of the fields", ->
+    @form.render()
+    expect( @form.getFields().length ).toEqual 6
+
   it "should load the model", ->
     @form.loadModel(@model)
     expect( @form.currentModel() ).toEqual @model

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/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,6 +96,42 @@ 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 ->
@@ -97,19 +144,19 @@ describe 'Component Event Binding', ->
         "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")
@@ -146,7 +193,7 @@ describe 'Component Event Binding', ->
 
   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")
@@ -186,3 +233,53 @@ describe 'Component Event Binding', ->
   it "should accept component events with a component getter", ->
     @container.getAlphaComponent().trigger "trigger:three"
     expect(@container).toHaveTriggered("three")
+
+
+describe 'Parent Container Tracking', ->
+  nestedContainer = Luca.register("Luca.components.NestedSpec")
+  nestedContainer.extends("Luca.core.Container")
+  nestedContainer.defines
+    name: "nested_container"
+    components:[
+      type: "container"
+      name: "one",
+      role: "one"
+      components:[
+        type: "container"
+        role: "two"
+        name: "two"
+        components:[
+          name: "three"
+          role: "three"
+        ]
+      ]
+    ]
+
+  it "should not have a parent unless created by a container", ->
+    nestedContainer = (new Luca.components.NestedSpec()).render()
+    expect( nestedContainer.getParent ).not.toBeDefined()
+
+  it "should know the root", ->
+    nestedContainer = (new Luca.components.NestedSpec()).render()
+    one = nestedContainer.getOne()
+    expect( one.getRootComponent().name ).toEqual 'nested_container'
+
+  it "should know the root", ->
+    nestedContainer = (new Luca.components.NestedSpec()).render()
+    two = nestedContainer.getTwo()
+    expect( two.getRootComponent().name ).toEqual 'nested_container'
+
+  it "should know its parent", ->
+    nestedContainer = (new Luca.components.NestedSpec()).render()
+    one = nestedContainer.getOne()
+    expect( one.getParent().name ).toEqual 'nested_container' 
+
+  it "should know its parent", ->
+    nestedContainer = (new Luca.components.NestedSpec()).render()
+    two = nestedContainer.getTwo()
+    expect( two.getParent().name ).toEqual 'one' 
+
+  it "should know its parent", ->
+    nestedContainer = (new Luca.components.NestedSpec()).render()
+    three = nestedContainer.getThree()
+    expect( three.getParent().name ).toEqual 'two'