luca 0.9.9 → 0.9.42

data/spec/{javascripts/core → core}/collection_spec.coffee

@@ -201,7 +201,7 @@ describe "Registering with the collection manager", ->
 
     registerSpy = sinon.spy()
 
-    privateCollection = new Luca.Collection [],
+    private = new Luca.Collection [],
       name: "private"
       manager: manager
       private: true
@@ -260,31 +260,6 @@ describe "The Model Bootstrap", ->
     expect( spy.called ).toBeTruthy()
 
 
-describe "Base Params on the URL Method", ->
-  beforeEach ->
-    @collection = new Luca.Collection [],
-      url: ()-> "/url/to/endpoint"    
-
-  afterEach ->
-    Luca.Collection.resetBaseParams()
-
-  it "should work with strings too", ->
-    collection = new Luca.Collection [], url: "/string/based/url"
-    expect( collection.url ).toEqual "/string/based/url"
-
-  it "should include base params in the url", ->
-    Luca.Collection.baseParams(base:"value")
-    expect( @collection.url() ).toEqual '/url/to/endpoint?base=value'
-    
-  it "should include params in the url", ->
-    @collection.applyParams(param:"value")
-    expect( @collection.url() ).toEqual '/url/to/endpoint?param=value'
-
-  it "should include one time params, in addition to base params", ->
-    Luca.Collection.baseParams(base:"value")
-    @collection.applyParams(one:"time")
-    expect( @collection.url() ).toEqual "/url/to/endpoint?base=value&one=time"
-
 
 
 

data/spec/core/container_spec.coffee

@@ -0,0 +1,66 @@
+describe 'The Luca Container', ->
+  beforeEach ->
+    @container = new Luca.core.Container
+      components:[
+        name: "component_one"
+        ctype: "view"
+        bodyTemplate: ()-> "markup for component one"
+        id: "c1"
+        value: 1
+        spy: sinon.spy()
+      ,
+        name: "component_two"
+        ctype: "view"
+        bodyTemplate: ()-> "markup for component two"
+        id: "c2"
+        value: 0
+        spy: sinon.spy()
+      ,
+        name: "component_three"
+        ctype: "container"
+        id: "c3"
+        value: 1
+        spy: sinon.spy()
+        components:[
+          ctype: "view"
+          name: "component_four"
+          bodyTemplate: ()-> "markup for component four"
+          spy: sinon.spy()
+        ]
+      ]
+
+  it "should trigger after initialize", ->
+    expect( @container ).toHaveTriggered "after:initialize"
+
+  it "should have some components", ->
+    expect( @container.components.length ).toEqual 3
+
+  it "should render the container and all of the sub views", ->
+    @container.render()
+    html=$(@container.el).html()
+    expect( html ).toContain "markup for component one"
+    expect( html ).toContain "markup for component two"
+
+  it "should render the container and all of the nested sub views", ->
+    @container.render()
+    html=$(@container.el).html()
+    expect( html ).toContain "markup for component four"
+
+  it "should select all components matching a key/value combo", ->
+    components = @container.select("value",1)
+    expect( components.length ).toEqual 2
+
+  it "should run a function on each component", ->
+    @container.eachComponent (c)-> c.spy()
+
+    _( @container.components ).each (component)->
+      expect( component.spy ).toHaveBeenCalled()
+
+  it "should run a function on each component including nested", ->
+    @container.render()
+    @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()

data/spec/{javascripts/core → core}/model_spec.coffee

@@ -14,15 +14,15 @@ describe "Luca.Model with computed attribute", ->
     computed:
       fullName: ['firstName', 'lastName']
 
-  it "should be undefined if dependences are not set", ->
+  it "should have it undefined if dependences are not set", ->
     model = new App.models.Sample
     expect(model.get("fullName")).toEqual(undefined)
 
-  it "should be undefined if callback function is not present", ->
+  it "should have it undefined if callback function is not present", ->
     model = new App.models.SampleWithoutCallback
     expect(model.get("fullName")).toEqual(undefined)
 
-  it "should not call the callback if dependences are not set", ->
+  it "should not call it's callback if dependences are not set", ->
     model = new App.models.Sample
     spy   = sinon.spy(model, "fullName")
     expect( spy.called ).toEqual(false)
@@ -48,26 +48,3 @@ 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"
-    property: true
-
-  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'
-
-  it "should read model object attributes as a fallback", ->
-    model = new ModelClass()
-    expect( model.read('property') ).toEqual true

data/spec/{javascripts/core → core}/view_spec.coffee

@@ -1,116 +1,3 @@
-describe "Inheriting Events", ->
-  beforeEach ->
-    eventTester = Luca.register("Luca.EventTester").extends("Luca.View")
-    eventTester.defines
-      _inheritEvents: 
-        "click input" : "clickHandler"  
-
-      bodyTemplate: ()->
-        "<input type='text' />"
-
-      clickHandler: ()->
-        @trigger("clicked:on:me")
-
-    inheritor = Luca.register("Luca.EventInheritor").extends("Luca.EventTester")
-    inheritor.defines
-      events:
-        "blur input": "blurHandler"
-
-      hmm: ()->
-        @trigger("hmm:what")
-
-      blurHandler: ()->
-        @trigger("blurred:me")    
-
-  it "should register event handlers", ->
-    view = new Luca.EventInheritor()
-    view.render()
-    view.registerEvent("keydown input", "hmm")
-    expect( view.events["keydown input"] ).toEqual "hmm"
-
-  it "should register event handlers", ->
-    view = new Luca.EventInheritor()
-    view.render()
-    expect( _(view.events).keys().length ).toEqual 2
-
-  it "should inherit dom events defined under _inheritEvents", ->
-    view = new Luca.EventInheritor()
-    view.render()
-    view.$('input').trigger("click")
-    expect( view ).toHaveTriggered("clicked:on:me")
-
-  it "should rely on events as normal", ->
-    view = new Luca.EventInheritor()
-    view.render()
-    view.$('input').trigger("blur")
-    expect( view ).toHaveTriggered("blurred:me")
-
-
-
-
-# In order to maintain backward compatibility with older apps,
-# I feel compelled to keep around the old deferrable hack job that is in place.
-#
-# However, selectively, I will go through and upgrade the way 
-# render() gets wrapped on luca components, so that the API is easier 
-# to understand.
-describe 'Rendering Strategies', ->
-  Luca.View.renderStrategies.spy = sinon.spy()
-  Luca.View.renderStrategies.spec = (_userSpecified)->
-    _userSpecified.call(@)
-    @trigger "strategy:trigger"
-    @  
-
-  window.AlternativeRenderingStrategy = Luca.View.extend
-    renderStrategy: "spec"
-    render: ( window.strategySpy = sinon.spy() )
-
-  it "should use a different strategy", ->
-    view = new AlternativeRenderingStrategy(renderStrategy: "spy")
-    view.render()
-    expect( Luca.View.renderStrategies.spy ).toHaveBeenCalled()
-
-  it "should use a different strategy", ->
-    view = new AlternativeRenderingStrategy()
-    view.render()
-    expect( view ).toHaveTriggered("strategy:trigger")
-
-  it "should call the user specified method", ->
-    view = new AlternativeRenderingStrategy()
-    view.render()
-    expect( window.strategySpy ).toHaveBeenCalled()
-
-# The improved rendering strategy is just that a view should be able
-# to get rendered(), fire its beforeRender hooks, and then defer the
-# 'expensive' part of the render 
-
-describe 'The Improved Rendering Strategy', ->
-  window.ImprovedRenderer = Luca.View.extend 
-    renderStrategy: "improved"    
-    render: ()->
-      window.improvedRenderSpy.call(@)
-
-  beforeEach ->
-    window.improvedRenderSpy = sinon.spy()
-
-  xit "should pause rendering if configured to be deferrable", ->
-    view = new ImprovedRenderer(deferrable:"wait:for:this")
-    view.render()
-    expect( view ).not.toHaveTriggered "after:render"
-
-  xit "should render normally if not configured to be deferrable", ->
-    view = new Luca.View(renderStrategy:"improved")
-    view.render()
-    expect( view ).toHaveTriggered("after:render")
-
-  xit "should resume rendering if configured to be deferrable", ->
-    view = new ImprovedRenderer(deferrable:"wait:for:this")
-    view.render()
-    view.trigger "wait:for:this"
-    expect( view ).toHaveTriggered("after:render")
-
-
-
 describe "Luca.View", ->
   it "should be defined", ->
     expect(Luca.View).toBeDefined()
@@ -151,6 +38,43 @@ describe "Luca.View", ->
     view = new Luca.View(additionalClassNames:"yes-yes yall")
     expect( view.$el.is(".yes-yes.yall") ).toEqual true
 
+
+describe "Development Tool Helpers", ->
+  beforeEach ->
+    _.def("Luca.views.IntrospectionView").extends("Luca.View").with
+      include:["Luca.DevelopmentToolHelpers"]
+
+    @view = new Luca.views.IntrospectionView 
+      events:
+        "click .a" : "clickHandler"
+        "hover .a" : "hoverHandler"
+
+      clickHandler: ()-> "click"
+      hoverHandler: ()-> "hover"
+
+      collection_one: new Luca.Collection([],name:"collection_one")
+      collection_two: new Luca.Collection([],name:"collection_two")
+      view_one: new Luca.View(name:"view_one")
+      view_two: new Luca.View(name:"view_two")
+      model_one: new Luca.Model(name:"model_one")
+      model_two: new Luca.Model(name:"model_two")
+
+  it "should know the names of functions which are event handlers", ->
+    names = @view.eventHandlerProperties()
+    expect( names ).toEqual ["clickHandler","hoverHandler"]
+
+  it "should know which properties are other views", ->
+    viewNames = _( @view.views() ).pluck("name")
+    expect( viewNames ).toEqual ["view_one","view_two"]
+
+  it "should know which properties are other models", ->
+    modelNames = _( @view.models() ).map (m)-> m.get('name')
+    expect( modelNames ).toEqual ["model_one","model_two"]
+
+  it "should know which properties are other collections", ->
+    collectionNames = _( @view.collections() ).pluck("name")
+    expect( collectionNames ).toEqual ["collection_one","collection_two"]
+
 describe "DOM Helper Methods", ->
   it "should use the $html method to inject into the $el", ->
     view = new Luca.View()
@@ -231,7 +155,7 @@ describe "The Collection Events API", ->
     @manager ||= new SampleManager()
     @collection = @manager.getOrCreate("sample")
 
-  xit "should call the resetHandler callback on the view", ->
+  it "should call the resetHandler callback on the view", ->
     view = new SampleView()
     collection = @manager.get("sample")
     collection.reset([])

data/spec/{javascripts/core/framework_spec.coffee → framework_spec.coffee}

@@ -1,4 +1,4 @@
-#= require "../helper"
+#= require "./helper"
 
 describe "The Luca Framework", ->
   it "should specify a version", ->
@@ -8,7 +8,7 @@ describe "The Luca Framework", ->
     expect(Luca).toBeDefined()
 
   it "should enable bootstrap by default", ->
-    expect(Luca.config.enableBoostrap).toBeTruthy()
+    expect(Luca.enableBootstrap).toBeTruthy()
 
   it "should have classes in the registry", ->
     expect( Luca.registry.classes ).toBeDefined()
@@ -113,32 +113,3 @@ 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
-
-