luca 0.8.599 → 0.9.0

data/lib/luca/code_browser.rb

@@ -0,0 +1,55 @@
+require 'sinatra/base'
+
+module Luca
+  class CodeBrowser < Sinatra::Base
+
+    class << self
+      attr_accessor :source_locations, :source_map
+    end
+
+    def self.look_for_source_in location=""
+      @source_locations ||= []
+      @source_locations << "#{ location }/**/*.coffee" if File.exists?(location)
+
+      @source_locations
+    end
+
+    def self.map_source
+      @source_map = {}
+
+      (self.source_locations || []).map do |location|
+        files = Dir.glob( location )
+        files.inject( @source_map ) do |memo, file|
+          definitions = IO.read(file).lines.to_a.grep /_\.def/
+
+          definitions.each do |definition|
+            component = definition.match(/_\.def\(['"](.+)['"]\)\./)
+
+            if component and component[1]
+              componentId = component[1].gsub(/['"].*$/,'')
+              memo[ componentId ] = file if componentId
+            end
+          end
+
+          memo
+        end
+      end
+
+      @source_map
+    end
+
+    def self.lookup_component component=""
+      map_source[ component ]
+    end
+
+    def self.get_component_source file=""
+      IO.read( file ) rescue ""
+    end
+
+    def self.get_source_for component=""
+      path_to_file = lookup_component( component )
+      get_component_source( path_to_file )
+    end
+
+  end
+end

data/lib/luca/rails/version.rb

@@ -1,6 +1,6 @@
 module Luca
   module Rails
-    VERSION = "0.8.599"
+    VERSION = "0.9.0"
   end
 end
 

data/lib/luca/rails.rb

@@ -2,6 +2,7 @@ module Luca
   module Rails
     require 'luca/template'
     require 'luca/test_harness'
+    require 'luca/code_browser'
     require 'luca/rails/engine'
     require 'luca/rails/version'
   end

data/spec/components/fields/checkbox_array_spec.coffee

@@ -0,0 +1,46 @@
+describe 'The Checkbox Array Field', ->
+  
+  beforeEach ->
+    @model = new Backbone.Model(item_ids: ["1"])
+    collection = new Luca.Collection
+    
+    @formView = new Luca.components.FormView
+      components:[
+        ctype: "checkbox_array"
+        name: 'item_ids'
+        collection: collection
+      ]
+
+    @formView.render()
+    @formView.loadModel(@model)
+    
+    collection.reset([
+      id: "1", name: "Item1"
+    ,
+      id: "2", name: "Item2"
+    ,
+      id: "3", name: "Item3"
+    ])
+    
+    @field = @formView.getFields()[0]
+    
+  it "should create a checkbox array field", ->
+    expect(@formView.currentModel()).toEqual(@model)
+    expect(@field.selectedItems).toEqual(["1"])
+
+  it "should render the list of checkboxes", ->
+    expect(@field.$el.html()).toContain("Item1")
+    expect(@field.$el.html()).toContain("Item2")
+    expect(@field.$el.html()).toContain("Item3")
+
+  it "should check off each checkbox in the collection that is selected", ->
+    expect(@field.$el.find("input[value='1']")[0].checked).toBeTruthy()
+    expect(@field.$el.find("input[value='2']")[0].checked).toBeFalsy()
+    expect(@field.$el.find("input[value='3']")[0].checked).toBeFalsy()
+  
+  it "should update the form model's attribute to be an array of selected items on click", ->
+    checkbox = $(@field.$el.find("input[value='2']")[0])
+    checkbox.prop("checked", true)
+    checkbox.click()
+
+    expect(@field.getModel().get('item_ids')).toEqual(["1", "2"])

data/spec/components/form_view_spec.coffee

@@ -40,6 +40,10 @@ describe 'The Form View', ->
     @form = new FormView()
     @model = new Model(field0:1,field1:"jonathan",field3:true,field4:"what up player?")
 
+  afterEach ->
+    @form = undefined
+    @model = undefined
+
   it "should create a form", ->
     expect( @form ).toBeDefined()
 
@@ -53,11 +57,13 @@ describe 'The Form View', ->
     values = @form.getValues()
     expect( values.field1 ).toEqual "jonathan"
 
-  it "should render the components", ->
+  it "should render the components within the body element", ->
+    @form.render()
+    expect( @form.$bodyEl().is('.form-view-body') ).toEqual true
+
+  it "should assign the components to render inside of the body", ->
     @form.render()
-    expect( @form.$el.html() ).toContain "Field Four"
-    expect( @form.$el.html() ).toContain "Field One"
-    expect( @form.$el.html() ).toContain "Click Me"
+    expect( @form.$bodyEl().html() ).toContain "Field Four"
 
   it "should allow me to set the values of the form fields with a hash", ->
     @form.render()

data/spec/containers/card_view_spec.coffee

@@ -19,6 +19,13 @@ describe "The Card View", ->
 
     @cardView.render()
 
+  it "should create three card elements", ->
+    expect( @cardView.componentElements().length ).toEqual 3
+
+  it "should hide all but one of the card elements", ->
+    display = _( @cardView.$('.luca-ui-card') ).map (el)-> $(el).css('display')
+    expect( display ).toEqual(['block','none','none'])
+
   it "should be able to find the cards by name", ->
     expect( @cardView.find("one") ).toBeDefined()
     expect( @cardView.find("one").one ).toEqual true

data/spec/core/collection_spec.coffee

@@ -1,5 +1,47 @@
 #### Luca.Collection
 
+setupCollection = ()->
+  window.cachedMethodOne = 0
+  window.cachedMethodTwo = 0
+
+  window.CachedMethodCollection = Luca.Collection.extend
+    cachedMethods:["cachedMethodOne","cachedMethodTwo"]
+
+    cachedMethodOne: ()->
+      window.cachedMethodOne += 1
+
+    cachedMethodTwo: ()->
+      window.cachedMethodTwo += 1
+
+describe "Method Caching", ->
+  beforeEach ->
+    setupCollection()
+    @collection = new CachedMethodCollection()
+
+  afterEach ->
+    @collection = undefined
+    window.CachedMethodCollection = undefined
+
+  it "should call the method", ->
+    expect( @collection.cachedMethodOne() ).toEqual 1
+
+  it "should cache the value of the method", ->
+    _( 5 ).times ()=> @collection.cachedMethodOne()
+    expect( @collection.cachedMethodOne() ).toEqual 1
+
+  it "should refresh the method cache upon reset of the models", ->
+    _( 3 ).times ()=> @collection.cachedMethodOne()
+    expect( @collection.cachedMethodOne() ).toEqual 1
+    @collection.reset()
+    _( 3 ).times ()=> @collection.cachedMethodOne()
+    expect( @collection.cachedMethodOne() ).toEqual 2
+
+  it "should restore the collection to the original configuration", ->
+    @collection.restoreMethodCache()
+    _( 5 ).times ()=> @collection.cachedMethodOne()
+    expect( @collection.cachedMethodOne() ).toEqual 6
+
+
 describe "Luca.Collection", ->
   it "should accept a name and collection manager", ->
     mgr = new Luca.CollectionManager()
@@ -36,6 +78,18 @@ describe "Luca.Collection", ->
 
     expect( registerSpy ).toHaveBeenCalled()
 
+  it "should query collection with filter", ->
+    models = []
+    models.push id: i, key: 'value' for i in [0..9]
+    models[3].key = 'specialValue'
+
+    collection = new Luca.Collection models
+
+    collection.applyFilter key: 'specialValue'
+
+    expect(collection.length).toBe 1
+    expect(collection.first().get('key')).toBe 'specialValue'
+
 describe "The ifLoaded helper", ->
   it "should fire the passed callback automatically if there are models", ->
     spy = sinon.spy()
@@ -171,7 +225,7 @@ describe "The Model Bootstrap", ->
 
   it "should fetch the cached models from the bootstrap", ->
     collection = new Luca.Collection [],
-      cached: ()-> "sample"
+      cache_key: ()-> "sample"
 
     collection.fetch()
 
@@ -180,14 +234,14 @@ describe "The Model Bootstrap", ->
 
   it "should reference the cached models", ->
     collection = new Luca.Collection [],
-      cached: ()-> "sample"
+      cache_key: ()-> "sample"
 
     expect( collection.cached_models().length ).toEqual(5)
 
   it "should avoid making an API call", ->
     spy = sinon.spy( Backbone.Collection.prototype.fetch )
     collection = new Luca.Collection [],
-        cached: ()-> "sample"
+        cache_key: ()-> "sample"
 
     collection.fetch()
     expect( spy.called ).toBeFalsy()
@@ -196,7 +250,7 @@ describe "The Model Bootstrap", ->
     spy = sinon.spy()
 
     collection = new Luca.Collection [],
-      cached: ()-> "sample"
+      cache_key: ()-> "sample"
       url: ()-> "/models"
 
     collection.bind "after:response", spy

data/spec/core/container_spec.coffee

@@ -3,15 +3,15 @@ describe 'The Luca Container', ->
     @container = new Luca.core.Container
       components:[
         name: "component_one"
-        ctype: "template"
-        markup: "markup for component one"
+        ctype: "view"
+        bodyTemplate: ()-> "markup for component one"
         id: "c1"
         value: 1
         spy: sinon.spy()
       ,
         name: "component_two"
-        ctype: "template"
-        markup: "markup for component two"
+        ctype: "view"
+        bodyTemplate: ()-> "markup for component two"
         id: "c2"
         value: 0
         spy: sinon.spy()
@@ -22,9 +22,9 @@ describe 'The Luca Container', ->
         value: 1
         spy: sinon.spy()
         components:[
-          ctype: "template"
+          ctype: "view"
           name: "component_four"
-          markup: "markup for component four"
+          bodyTemplate: ()-> "markup for component four"
           spy: sinon.spy()
         ]
       ]

data/spec/core/view_spec.coffee

@@ -1,8 +1,4 @@
 describe "Luca.View", ->
-  Custom = Luca.View.extend
-    clickHandler: sinon.spy()
-    autoBindEventHandlers: true
-
   it "should be defined", ->
     expect(Luca.View).toBeDefined()
 
@@ -16,16 +12,99 @@ describe "Luca.View", ->
 
   it "should register the view in the cache", ->
     view = new Luca.View(name:"cached")
-    expect( Luca.cache("cached") ).toBeDefined()
+    expect( Luca.cache("cached") ).toEqual(view)
 
   it "should trigger after initialize", ->
     view = new Luca.View()
     expect( view ).toHaveTriggered("after:initialize")
 
-  it "should auto-bind event handlers", ->
-    # pending
+  it "should be picked up by the isBackboneView helper", ->
+    view = new Luca.View()
+    expect( Luca.isBackboneView(view) ).toEqual true
+
+  it "should be picked up by the isBackboneComponent helper", ->
+    view = new Luca.View()
+    expect( Luca.isComponent(view) ).toEqual true
+
+  it "should be picked up by the supportsBackboneEvents helper", ->
+    view = new Luca.View()
+    expect( Luca.supportsBackboneEvents(view) ).toEqual true
+
+  it "should append additional class names to the view's $el", ->
+    view = new Luca.View(additionalClassNames:["yes-yes","yall"])
+    expect( view.$el.is(".yes-yes.yall") ).toEqual true
+
+  it "should accept a string for additional class names", ->
+    view = new Luca.View(additionalClassNames:"yes-yes yall")
+    expect( view.$el.is(".yes-yes.yall") ).toEqual true
+
+
+describe "Introspection Helpers", ->
+  beforeEach ->
+    @view = new Luca.View
+      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()
+    view.$html('haha')
+    expect( view.$html() ).toEqual 'haha'
+
+describe "Deferrable Rendering", ->
+  beforeEach ->
+    @fetchSpy   = sinon.spy()
+    @customSpy  = sinon.spy()
+
+    @collection = new Luca.Collection
+      url: "/models"
+      fetch: @fetchSpy
+      custom: @customSpy
+      name: "haha"
+
+    @DeferrableView = Luca.View.extend
+      name: "deferrable_view"
+      deferrable: @collection
+
+    @TriggeredView = Luca.View.extend
+      deferrable: @collection
+      deferrable_method: "custom"
+
+  it "should automatically call fetch on the collection ", ->
+    ( new @DeferrableView ).render()
+    @server.respond()
+    expect( @fetchSpy ).toHaveBeenCalled()
+
+  it "should call a custom method if configured", ->
+    ( new @TriggeredView ).render()
+    expect( @customSpy ).toHaveBeenCalled()
 
 describe "Hooks", ->
   it "should have before and after render hooks", ->
@@ -85,3 +164,10 @@ describe "The Collection Events API", ->
     collection = @manager.get("sample")
     collection.reset([])
     expect( view.resetHandler ).toHaveBeenCalled()
+
+
+describe "Code Refresh", ->
+  beforeEach ->
+
+  it "should reference the event handler function property names", ->
+  it "should reference the event handler functions", ->

data/spec/framework_spec.coffee

@@ -18,7 +18,7 @@ describe "The Luca Framework", ->
 
   it "should allow me to add view namespaces to the registry", ->
     Luca.registry.addNamespace("Test.namespace")
-    expect( Luca.registry.namespaces ).toContain("Test.namespace")
+    expect( Luca.registry.namespaces(false) ).toContain("Test.namespace")
 
   it "should resolve a value.string to the object", ->
     window.nested =
@@ -31,18 +31,17 @@ describe "The Luca Framework", ->
 
   it "should create an instance of a class by ctype", ->
     object =
-      ctype: "template"
-      template: "components/form_view"
+      ctype: "view"
 
     component = Luca.util.lazyComponent(object)
-    expect( _.isFunction(component.render) ).toBeTruthy()
+
+    expect( Luca.isBackboneView(component) ).toEqual true
 
   it "should find a created view in the cache", ->
-    template = new Luca.components.Template
-      template: "components/form_view"
+    template = new Luca.View
       name: 'test_template'
 
-    expect(Luca.cache("test_template")).toBeDefined()
+    expect( Luca.isBackboneView( Luca.cache("test_template") ) ).toEqual true
 
   it "should detect if an object is probably a backbone view", ->
     obj =
@@ -79,14 +78,14 @@ describe "Luca Component Definition", ->
     expect( Luca.random ).toBeDefined()
 
   it "should automatically register the namespace in the registry", ->
-    expect( Luca.registry.namespaces ).toContain 'Luca.random'
+    expect( Luca.registry.namespaces() ).toContain Luca.random
 
   it "should automatically register the component in the registry", ->
     expect( Luca.registry.lookup("component_definition") ).toBeDefined()
 
   it "should reference the name of the extending class", ->
     instance = new Luca.random.ComponentDefinition
-    expect( instance._className ).toEqual "Luca.random.ComponentDefinition"
+    expect( instance.displayName ).toEqual "Luca.random.ComponentDefinition"
 
   it "should reference the extended class", ->
     instance = new Luca.random.ComponentDefinition
@@ -94,12 +93,16 @@ describe "Luca Component Definition", ->
 
   it "should reference the name of the extended class", ->
     instance = new Luca.random.ComponentDefinition
-    expect( instance._superClass()._className ).toEqual 'Luca.View'
+    expect( instance._superClass().displayName ).toEqual 'Luca.View'
 
   it "should use the backbone.extend functionality properly", ->
     instance = new Luca.random.ComponentDefinition
     expect( instance.property ).toEqual "value"
 
-  it "should alias to _.component", ->
-    proxy = _.component('Luca.random.ComponentDefition')
+  it "should alias to _.def", ->
+    proxy = _.def('Luca.random.ComponentDefition')
     expect( proxy.with ).toBeDefined()
+
+  it "should allow me to set the namespace before the definition", ->
+    Luca.util.namespace("Luca.View")
+    expect( Luca.util.namespace() ).toEqual Luca.View

data/src/components/application.coffee

@@ -1,25 +1,77 @@
-_.component('Luca.Application').extends('Luca.containers.Viewport').with
-
+_.def('Luca.Application').extends('Luca.containers.Viewport').with
+
+  # automatically starts the @router
+  # if it exists, once the components
+  # for the application have been created
+  autoStartHistory: true
+
+  # we will create a collection manager singleton
+  # by default unless otherwise specified
+  useCollectionManager: true
+
+  # Luca plugin apps are apps which mount onto existing
+  # luca apps, and will not have the behavior of a main
+  # app which acts as a singleton
+  plugin: false
+
+  # by default, the application will use a controller
+  # component, which is a card view container which shows
+  # one view at a time.  this is useful for having an application
+  # with several 'pages' so to speak
+  useController: true
+
+  #### Nested Components
+
+  # applications have one component, the controller.
+  # any components defined on the application class directly
+  # will get wrapped by the main controller unless you
+  # set useController = false
   components:[
-    ctype: 'controller'
-    name: 'main_controller'
-    defaultCard: 'welcome'
-    components:[
-      ctype: 'template'
-      name: 'welcome'
-      template: 'sample/welcome'
-      templateContainer: "Luca.templates"
-    ]
+    ctype: 'template'
+    name: 'welcome'
+    template: 'sample/welcome'
+    templateContainer: "Luca.templates"
   ]
 
   initialize: (@options={})->
     Luca.containers.Viewport::initialize.apply @, arguments
 
-    @collectionManager ||= Luca.CollectionManager.get?() || new Luca.CollectionManager()
+    if @useController is true
+      definedComponents = @components || []
+
+    @components = [
+      ctype: 'controller'
+      name: "main_controller"
+      components: definedComponents
+    ]
+
+    if @useCollectionManager is true
+      @collectionManager ||= Luca.CollectionManager.get?()
+      @collectionManager ||= new Luca.CollectionManager( @collectionManagerOptions||={} )
 
     @state = new Backbone.Model( @defaultState )
 
-    @bind "ready", ()=> @render()
+    # we will render when all of the various components
+    # which handle our data dependencies determine that
+    # we are ready
+    @bind "ready", ()=>
+      @render()
+    # the keyRouter allows us to specify
+    # keyEvents on our application with an API very similar
+    # to the DOM events API for Backbone.View
+    #
+    # Example:
+    #
+    # keyEvents:
+    #   meta:
+    #     forwardslash: "altSlashHandler"
+    @setupKeyRouter() if @useKeyRouter is true and @keyEvents?
+
+    # if the application is a plugin designed to modify the behavior
+    # of another app, then don't claim ownership.  otherwise the most common
+    # use-case is that there will be one application instance
+    unless @plugin is true
+      Luca.getApplication = ()=> @
 
   activeView: ()->
     if active = @activeSubSection()
@@ -33,6 +85,17 @@ _.component('Luca.Application').extends('Luca.containers.Viewport').with
   activeSection: ()->
     @get("active_section")
 
+  beforeRender: ()->
+    Luca.containers.Viewport::beforeRender?.apply(@, arguments)
+
+    if @router? and @autoStartHistory is true
+      routerStartEvent = @startRouterOn || "after:render"
+
+      if routerStartEvent is "before:render"
+        Backbone.history.start()
+      else
+        @bind routerStartEvent, ()-> Backbone.history.start()
+
   afterComponents: ()->
     Luca.containers.Viewport::afterComponents?.apply @, arguments
 
@@ -48,9 +111,6 @@ _.component('Luca.Application').extends('Luca.containers.Viewport').with
         component.bind "after:card:switch", (previous,current)=>
           @state.set(active_sub_section:current.name)
 
-  beforeRender: ()->
-    Luca.containers.Viewport::beforeRender?.apply @, arguments
-    #Backbone.history.start()
 
   # boot should trigger the ready event, which will call the initial call
   # to render() your application, which will have a cascading effect on every
@@ -72,10 +132,58 @@ _.component('Luca.Application').extends('Luca.containers.Viewport').with
     @state.get(attribute)
 
   getMainController: ()->
-    @view("main_controler")
+    return @components[0] if @useController is true
+    Luca.cache('main_controller')
 
   set: (attributes)->
     @state.set(attributes)
 
-  view: (name)-> Luca.cache(name)
+  view: (name)->
+    Luca.cache(name)
+
+  #### Navigation Hooks
+  #
+  # delegate to the main controller so that we can switch the active section
+  navigate_to: (component_name, callback)->
+    @getMainController().navigate_to(component_name, callback)
+
+  setupKeyRouter: ()->
+    return unless @keyEvents
+
+    @keyEvents.control_meta ||= {}
+
+    # allow for both meta_control, control_meta for the combo
+    _.extend(@keyEvents.control_meta, @keyEvents.meta_control) if @keyEvents.meta_control
+
+    router = _.bind(@keyRouter, @)
+
+    $( document ).keydown( router )
+
+  #### Key Router
+  #
+  # TODO: Define a syntax for mapping combinations of meta, control, and keycodes
+  # to some sort of method delegation system that the application handles.
+  keyRouter: (e)->
+    return unless e and @keyEvents
+
+    isInputEvent = $(e.target).is('input') || $(e.target).is('textarea')
+
+    return if isInputEvent
+
+    keyname = Luca.keyMap[ e.keyCode ]
+
+    return unless keyname
+
+    meta = e?.metaKey is true
+    control = e?.ctrlKey is true
+
+    source = @keyEvents
+    source = if meta then @keyEvents.meta else source
+    source = if control then @keyEvents.control else source
+    source = if meta and control then @keyEvents.meta_control else source
 
+    if keyEvent = source?[keyname]
+      if @[keyEvent]?
+        @[keyEvent]?.call(@)
+      else
+        @trigger(keyEvent)

data/src/components/base_toolbar.coffee

@@ -1,4 +1,4 @@
-_.component('Luca.components.Toolbar').extends('Luca.core.Container').with
+_.def('Luca.components.Toolbar').extends('Luca.core.Container').with
 
   className: 'luca-ui-toolbar'
 
@@ -9,7 +9,7 @@ _.component('Luca.components.Toolbar').extends('Luca.core.Container').with
 
   prepareComponents: ()->
     _( @components ).each (component)=>
-      component.container = @el
+      component.container = @$el
 
   render: ()->
     $(@container).append(@el)