luca 0.9.76 → 0.9.89

data/spec/{containers → javascripts/containers}/card_view_spec.coffee

@@ -39,9 +39,14 @@ describe "The Card View", ->
 
   it "shouldn't fire first activation on a component", ->
     expect( @cardView.find("two")?.firstActivation ).not.toHaveBeenCalled()
+    expect( @cardView.find("two") ).not.toHaveTriggered("first:activation")
 
   it "should fire firstActivation on a component", ->
+    console.log "Card Viw", @cardView.find("two"), @cardView.find("two").previously_activated, @cardView.find("two").rendered
+    
+
     @cardView.activate("two")
+    expect( @cardView.find("two") ).toHaveTriggered("first:activation")
     expect( @cardView.find("two")?.firstActivation ).toHaveBeenCalled()
 
   it "should fire deactivation on a component", ->

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

@@ -260,6 +260,31 @@ 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 → javascripts/core}/container_spec.coffee

@@ -1,6 +1,6 @@
 describe 'The Luca Container', ->
   beforeEach ->
-    c = @container = new Luca.core.Container
+    c = @container = new Luca.Container
       defaults:
         defaultProperty: 'it_works'
       extensions:[
@@ -43,6 +43,8 @@ describe 'The Luca Container', ->
         ]
       ]
 
+    @container.on "before:attach", ()->
+      console.log "before attach", @, arguments
     @container.render()
 
   it "should create getter methods on the for components with roles", ->
@@ -98,7 +100,7 @@ describe 'The Luca Container', ->
 
 describe 'Component Inheritance and Customization', ->
   it "should accept an array for extensions configuration and join on position/index", ->
-    container = new Luca.core.Container
+    container = new Luca.Container
       extensions:[
         undefined
       ,
@@ -117,7 +119,7 @@ describe 'Component Inheritance and Customization', ->
     expect( container.getComponentTwo().name ).toEqual "custom_two"
 
   it "should accept an object for extensions configuration and join using role", ->
-    container = new Luca.core.Container
+    container = new Luca.Container
       extensions:
         component_one:
           name: "custom_one"
@@ -135,7 +137,7 @@ describe 'Component Inheritance and Customization', ->
 
 describe 'Component Event Binding', ->
   beforeEach ->
-    @container = new Luca.core.Container
+    @container = new Luca.Container
       componentEvents:
         "haha trigger:one"                  : "one"
         "alpha trigger:two"                 : "two"
@@ -162,7 +164,7 @@ describe 'Component Event Binding', ->
         @getGamma().trigger("after:render:gamma")
 
       registerComponentEvents: ()->
-        Luca.core.Container::registerComponentEvents.apply(@, arguments)
+        Luca.Container::registerComponentEvents.apply(@, arguments)
 
       components:[
         name: "component_alpha"
@@ -237,7 +239,7 @@ describe 'Component Event Binding', ->
 
 describe 'Parent Container Tracking', ->
   nestedContainer = Luca.register("Luca.components.NestedSpec")
-  nestedContainer.extends("Luca.core.Container")
+  nestedContainer.extends("Luca.Container")
   nestedContainer.defines
     name: "nested_container"
     components:[

data/spec/javascripts/core/events_spec.coffee

@@ -0,0 +1,26 @@
+describe 'The Event Helpers', ->
+  describe 'The Event Relayer', ->
+    beforeEach ->
+      @a = new Luca.View(name:"a")
+      @b = new Luca.View(name:"b")
+
+      (new Luca.EventRelayer
+        target: @a 
+        source: @b
+        prefix: "prefix"
+        events:[
+          "event:one"
+          "event:two"
+          "event:three"
+        ]).setup()
+
+    xit 'should relay events from component a to component b', ->
+      @b.trigger("event:one")
+      @b.trigger("event:two")
+      @b.trigger("event:three")
+
+      expect( @a ).toHaveTriggered("prefix:event:one")
+      expect( @a ).toHaveTriggered("prefix:event:two")
+      expect( @a ).toHaveTriggered("prefix:event:three")
+
+

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

@@ -1,4 +1,4 @@
-#= require "./helper"
+#= require "../helper"
 
 describe "The Luca Framework", ->
   it "should specify a version", ->

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

@@ -1,9 +1,9 @@
 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"
+      component = "Luca.Container"
       cssClass = Luca.util.toCssClass(component)
-      expect( cssClass ).toEqual 'luca-core-container'
+      expect( cssClass ).toEqual 'luca-container'
 
     it "should produce a css class from the component class name", ->
       component = "Luca.components.MultiCollectionView"

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

@@ -1,3 +1,116 @@
+describe "Inheriting Events", ->
+  beforeEach ->
+    eventTester = Luca.register("Luca.EventTester").extends("Luca.View")
+    eventTester.defines
+      _events: 
+        "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 _events", ->
+    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()
@@ -38,43 +151,6 @@ 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()
@@ -155,7 +231,7 @@ describe "The Collection Events API", ->
     @manager ||= new SampleManager()
     @collection = @manager.getOrCreate("sample")
 
-  it "should call the resetHandler callback on the view", ->
+  xit "should call the resetHandler callback on the view", ->
     view = new SampleView()
     collection = @manager.get("sample")
     collection.reset([])

data/spec/javascripts/dependencies/index.coffee

@@ -0,0 +1,3 @@
+#= require jasmine
+#= require jasmine-html
+#= require sinon

data/spec/lib/component_definition_spec.rb

@@ -0,0 +1,63 @@
+require "spec_helper"
+
+describe ComponentDefinition do
+  let(:path) { File.join(Rails.root,"spec","support","fixtures","component.coffee")}
+  let(:definition) { ComponentDefinition.new(path) }
+
+  it "should be valid" do
+    definition.should be_valid
+  end
+
+  it "should recognize the class being defined" do
+    definition.class_name.should == "Luca.SampleComponent"
+  end
+
+  it "should know the type alias" do
+    definition.type_alias.should == "sample_component"
+  end
+
+  it "should be view based" do
+    definition.should be_view_based
+  end
+
+  it "should have a css class identifier" do
+    definition.css_class_identifier.should == "luca-sample-component"
+  end
+
+  it "should know the class it extends" do
+    definition.extends.should == "Luca.View"
+  end
+
+  it "should detect the definition variable name" do
+    definition.definition_proxy_variable_name.should == "component"
+  end
+
+  it "should tell me which methods are defined" do
+    definition.defines_methods.should == ["methodOne","methodTwo"]
+  end
+
+  it "should tell me which properties are defined" do
+    definition.defines_properties.should == ["privateSetting","el","bodyClassName", "publicSetting"]
+  end
+
+  it "should tell me where a method is defined" do
+    definition.find_definition_of("methodOne").line_number.should > 0
+  end
+
+  it "should tell me where a property is defined" do
+    definition.find_definition_of("privateSetting").line_number.should > 0
+  end
+
+  it "should find the documentation for a method definition" do
+    definition.find_comments_above("methodOne").should_not be_empty
+  end
+
+  it "should produce human readable documentation for a method definition" do
+    definition.documentation_for("methodOne").should == "here is some documentation for methodOne"
+  end
+
+  it "should not pick up things which aren't documentation" do
+    definition.documentation_for("bodyClassName").should == ""
+  end
+
+end

data/spec/lib/input_compiler_spec.rb

@@ -0,0 +1,9 @@
+require "spec_helper"
+
+describe AssetCompiler do
+  xit "should compile coffeescript" do 
+    input = "console.log(foo) for foo in [1,2,3]"
+    compiler = AssetCompiler.new(mode:"coffeescript", input: input)
+    compiler.output.should == "haha"
+  end
+end

data/spec/lib/luca_application_spec.rb

@@ -0,0 +1,30 @@
+require "spec_helper"
+
+describe LucaApplication do
+  let(:repo) { LucaApplication.new("tools") }
+  let(:application_file_path) { File.join(repo.send(:coffeescripts_location),'tools_application.coffee') }
+
+  it "should retrieve source code for a component" do
+    source_length = repo.source_code_for_class("Tools.Application").length
+    file_length = File.size( repo.find_definition_file_for_class('Tools.Application') )
+    file_length.should be_within(5).of( source_length ) 
+  end
+
+  it "should map all component definitions to their respective files" do
+    map = repo.component_definition_filemap
+    map["Tools.Application"].should == application_file_path
+  end
+
+  xit "should find a template object by its filename" do
+  end
+
+  it "should find a component definition by class name" do
+    repo.find_component_definition_for_class('Tools.Application').should be_present
+    repo.find_component_definition_for_class('Tools.Collection').should be_present
+  end
+
+  it "should detect the namespace" do
+    repo.namespace.should == "Tools"
+  end
+
+end