luca 0.9.9 → 0.9.42

data/spec/javascripts/core/container_spec.coffee

@@ -1,287 +0,0 @@
-describe 'The Luca Container', ->
-  beforeEach ->
-    c = @container = new Luca.Container
-      defaults:
-        defaultProperty: 'it_works'
-      extensions:[
-        extension: 1
-      ,
-        extension: 2
-      ,
-        extension: 3
-      ]
-      components:[
-        name: "component_one"
-        ctype: "view"
-        defaultProperty: "oh_yeah"
-        bodyTemplate: ()-> "markup for component one"
-        id: "c1"
-        value: 1
-        getter: "getOne"
-        spy: sinon.spy()
-        role: "role_one"
-      ,
-        name: "component_two"
-        ctype: "view"
-        bodyTemplate: ()-> "markup for component two"
-        id: "c2"
-        value: 0
-        spy: sinon.spy()
-        role: "role_two"
-        getter: "getComponentTwo"
-      ,
-        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()
-        ]
-      ]
-
-    @container.on "before:attach", ()->
-      console.log "before attach", @, arguments
-    @container.render()
-
-  it "should create getter methods on the for components with roles", ->
-    expect( @container.getRoleTwo ).toBeDefined()
-
-  it "should create getter methods on the for components with roles", ->
-    expect( @container.getRoleTwo().name ).toEqual 'component_two'
-
-  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')
-    expect( defaults.length ).toEqual(2)
-    expect( custom.length ).toEqual(1)
-
-  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.selectByAttribute("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()
-
-describe 'Component Inheritance and Customization', ->
-  it "should accept an array for extensions configuration and join on position/index", ->
-    container = new Luca.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.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.Container
-      componentEvents:
-        "haha trigger:one"                  : "one"
-        "alpha trigger:two"                 : "two"
-        "getAlphaComponent trigger:three"   : "three"
-        "* trigger:four"                    : "four"
-        "beta trigger:five"                 : "five"
-
-      one: ()->
-        @trigger "one"
-
-      two: ()->
-        @trigger "two"
-
-      three: ()->
-        @trigger "three"
-
-      four: ()->
-        @trigger "four"
-
-      five: ()->
-        @trigger "five"
-
-      afterRender: ()->
-        @getGamma().trigger("after:render:gamma")
-
-      registerComponentEvents: ()->
-        Luca.Container::registerComponentEvents.apply(@, arguments)
-
-      components:[
-        name: "component_alpha"
-        role: "alpha"
-        getter: "getAlphaComponent"
-      ,
-        name: "container_tester"
-        type: "container"
-        components:[
-          name: "beta_view"
-          role: "beta"
-          components:[
-            role: "gamma"
-            name: "haha"
-          ]
-        ]
-      ]
-
-    @container.render()
-
-  it "should give me all of the components", ->
-    names = _( @container.allChildren() ).pluck('name')
-    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 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 a nested component by name", ->
-    expect( @container.findComponentByName('haha') ).toBeDefined()
-
-  it "should find the component by its name", ->
-    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()
-
-  it "should accept wildcard for component", ->
-    @container.getAlphaComponent().trigger "trigger:four"
-    expect( @container ).toHaveTriggered("four")
-
-  it "should accept component events with a component name", ->
-    @container.getGamma().trigger "trigger:one"
-    expect(@container).toHaveTriggered("one")
-
-  it "should accept component events with a component role", ->
-    @container.getAlphaComponent().trigger "trigger:two"
-    expect(@container).toHaveTriggered("two")
-
-  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.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'    

data/spec/javascripts/core/define_spec.coffee

@@ -1,116 +0,0 @@
-describe 'The Component Definition System', ->
-  beforeEach ->
-    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", ->
-    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", ->
-    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 know the private methods", ->
-      expect( @metaData.privateMethods() ).toContain('privateMethod')
-      expect( @metaData.privateMethods() ).not.toContain('privateAttribute')
-
-    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/javascripts/core/events_spec.coffee

@@ -1,26 +0,0 @@
-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/javascripts/core/field_spec.coffee

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

data/spec/javascripts/core/util_spec.coffee

@@ -1,24 +0,0 @@
-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.Container"
-      cssClass = Luca.util.toCssClass(component)
-      expect( cssClass ).toEqual 'luca-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/spec/javascripts/dependencies/index.coffee

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

data/spec/lib/component_definition_spec.rb

@@ -1,63 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

data/spec/support/fixtures/application.coffee

@@ -1,45 +0,0 @@
-application = Tools.register      "Tools.Application"
-application.extends               "Luca.Application" 
-
-application.configuration
-  el: '#viewport'
-  bodyClassName: "viewport-body"
-
-  bindMethods:[
-    "toggleLayout"
-  ]
-
-  topToolbar:
-    buttons:[
-      label: "Toggle Layout"
-      eventId: "toggle:layout"
-    ]
-
-  bottomToolbar:
-    buttons:[]
-
-  fluid: false
-  applyWrapper: false
-  autoBoot: false
-  useController: false
-  name: 'ToolsApp'
-  router:             "Tools.Router"
-  collectionManager:  "ToolsCollectionManager"
-
-application.contains
-  type: "component_inspector"
-  role: "component_inspector"
-  className: "work-area row-fluid"
-
-application.publicMethods
-  currentApplication: ()->
-    "tools"
-    
-  toggleLayout: ()->
-    Tools().getComponentInspector().cycleLayout()
-
-application.privateMethods
-  boundaries: ()->
-    [0,60,400,460]
-
-application.register()

data/spec/support/fixtures/component.coffee

@@ -1,34 +0,0 @@
-# This is a sample component definition file 
-# for the luca framework.  The header of the file
-# is used to describe the general purpose of the component.
-component = Luca.register "Luca.SampleComponent"
-component.extends         "Luca.View"
-
-# We can comment on a specific entry such as the mixins.
-component.mixesIn         "SomeMixin"
-
-component.privateConfiguration
-  # this is a basic description of the private setting.
-  # expects: Boolean
-  privateSetting: false 
-  el: '#viewport'
-  bodyClassName: "viewport-body"
-  
-component.publicConfiguration
-  # this is a comment for the public setting
-  publicSetting: ["1,2,3"]
-  
-component.publicMethods
-  # here is some documentation for methodOne 
-  methodOne: ()->
-    @thisIsSomeMethodicalShitSon()
-    @puttingAllsortsOfCode
-      allUp: "InYo"
-      bidness: "Baby"
-
-  # here is a multi line comment for methodTwo
-  # it is pretty dope
-  # that i can do this
-  methodTwo: (butThistime="withSomArguments", youKnow=[], man={})->
-    @okCool()
-