luca 0.9.9 → 0.9.42

data/spec/javascripts/components/collection_view_spec.coffee

@@ -1,59 +0,0 @@
-describe 'The Collection View', ->
-  beforeEach ->
-    @collection = new Luca.Collection([
-      id: 1, attr: "value_one", filter: "value"
-    ,
-      id: 2, attr: "value_two", filter: "value"
-    ],
-    model: Luca.Model)
-
-    @view = new Luca.components.CollectionView
-      itemTagName: "li"
-      itemClassName: "custom-class"
-      itemProperty: 'attr'
-      collection: @collection
-      filterable:
-        query:
-          filter: "value"
-        options:
-          sortBy: "filter"
-
-    @view.render()
-
-  it "should provide access to the query", ->
-    expect( @view.getQuery() ).toBeDefined()
-
-  it "should provide access to the query options", ->
-    expect( @view.getQueryOptions() ).toBeDefined()
-
-  it "should combine filter and pagination in the options hash", ->
-    @view.setPage(5)
-    @view.applyFilter({filter:"value"},{sortBy:'filter'})
-
-    options = @view.getQueryOptions()
-    query = @view.getQuery()
-
-    expect( options.page ).toEqual 5
-    expect( options.sortBy ).toEqual 'filter'
-    expect( query.filter ).toEqual 'value'
-
-  it "should render the attributes in the specified list elements", ->
-    expect( @view.$html().match(/value_one/) ).toBeTruthy()
-
-  it "should render each of the attributes", ->
-    expect( @view.$('li.custom-class').length ).toEqual 2
-
-  it "should locate a dom element by luca model id", ->
-    expect( @view.locateItemElement(2).html() ).toContain('value_two')
-
-  it "should refresh the view when a model is added", ->
-    @view.collection.add(attr:"value_three",id:3)
-    expect( @view ).toHaveTriggered('after:refresh')
-
-  it "should refresh the view when a model is removed", ->
-    @view.collection.remove( @view.collection.at(0) )
-    expect( @view ).toHaveTriggered('after:refresh')
-
-
-
-

data/spec/javascripts/components/controller_spec.coffee

@@ -1,62 +0,0 @@
-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 track controller activation events", ->
-    two = @controller.navigate_to("two")
-    expect( two.activatedByController ).toBeTruthy()
-
-  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/javascripts/components/form_view_spec.coffee

@@ -1,162 +0,0 @@
-describe 'The Form View', ->
-  beforeEach ->
-    FormView = Luca.components.FormView.extend
-      components:[
-        ctype: 'hidden_field'
-        name: 'id'
-      ,
-
-        ctype: "text_field",
-        label: "Field Two"
-        name: "field2"
-      ,
-        ctype: "text_field",
-        label: "Field One"
-        name: "field1"
-      ,
-        ctype: "checkbox_field"
-        label: "Field Three"
-        name: "field3"
-      ,
-        name: "field4"
-        label: "Field Four"
-        ctype: "text_area_field"
-      ,
-        name: "field5"
-        ctype: "button_field"
-        label: "Click Me"
-      ]
-
-    Model = Backbone.Model.extend
-      schema:
-        field0: "hidden"
-        field2: "text"
-        field1: "text"
-        field3: "boolean"
-        field4: "blob"
-        field5:
-          collection: "sample"
-
-    @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()
-
-  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
-
-  it "should set the field values from the model when loaded", ->
-    @form.render()
-    @form.loadModel(@model)
-    values = @form.getValues()
-    expect( values.field1 ).toEqual "jonathan"
-
-  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.$bodyEl().html() ).toContain "Field Four"
-
-  it "should allow me to set the values of the form fields with a hash", ->
-    @form.render()
-    @form.setValues(field1:"yes",field2:"no")
-    values = @form.getValues()
-
-    expect( values.field1 ).toEqual "yes"
-    expect( values.field2 ).toEqual "no"
-
-  it "should sync the model with the form field values", ->
-    @form.render()
-    @form.loadModel(@model)
-    @form.setValues(field1:"yes")
-    expect( @form.getValues().field1 ).toEqual "yes"
-
-describe 'Dirty Tracking', ->
-  Luca.register("Luca.components.DirtyForm").extends("Luca.components.FormView").defines
-    trackDirtyState: true
-    components:[
-      type: "text"
-      name: "dirty_field"
-    ]
-
-  beforeEach -> 
-    (@dirtyForm = new Luca.components.DirtyForm()).render()
-
-
-  it "should be stateful", ->
-    expect( @dirtyForm.state ).toBeDefined()
-    expect( @dirtyForm.state.set('dirty', true) )
-    expect( @dirtyForm ).toHaveTriggered("state:change:dirty")
-
-  it "should start off in a clean state", ->
-    dirty = @dirtyForm.isDirty()
-    expect( dirty ).not.toBeTruthy()
-
-  it "should become dirty if a field changes", ->
-    @dirtyForm.getField('dirty_field').trigger("on:change")
-    dirty = @dirtyForm.isDirty()
-    expect( dirty ).toBeTruthy()
-
-  it "should trigger a state change event", ->
-    @dirtyForm.getField('dirty_field').trigger("on:change")
-    expect( @dirtyForm ).toHaveTriggered('state:change:dirty')
-  
-  it "should bubble up field change events", ->  
-    @dirtyForm.getField('dirty_field').trigger("on:change")
-    expect( @dirtyForm ).toHaveTriggered('field:change')
-
-  it "should become clean on a reset", ->
-    @dirtyForm.getField('dirty_field').trigger("on:change")
-    @dirtyForm.reset()
-    dirty = @dirtyForm.isDirty()
-    expect( dirty ).not.toBeTruthy()
-
-describe 'Model Binding', ->
-  Luca.register("Luca.FormModel").extends("Luca.Model").defines(defaults:model_field:"value")
-
-  form = Luca.register('Luca.components.ModelBoundForm')
-
-  form.extends("Luca.components.FormView")
-
-  form.defines
-    trackModelChanges: true
-    components:[
-      type: "text"
-      name: "model_field"
-    ]
-
-  beforeEach ->
-    @modelForm = new Luca.components.ModelBoundForm()
-    @formModel = new Luca.FormModel()
-    @modelForm.render()
-    @modelForm.loadModel(@formModel)
-
-  it "should trigger a state change event", ->
-    expect( @modelForm ).toHaveTriggered("state:change:currentModel")
-
-  it "should not bind to model changes by default", ->
-    expect( Luca.components.FormView::trackModelChanges ).not.toBeTruthy()
-
-  it "should be setup to track model changes", ->
-    expect( @modelForm.trackModelChanges ).toBeTruthy()
-
-  it "should change the model's value when the form applies itself", ->
-    @modelForm.setValues('model_field':"smooth, baby")
-    @modelForm.applyFormValuesToModel()
-    expect( @modelForm.getField('model_field').getValue() ).toEqual 'smooth, baby'
-
-  it "should change the field's value when the underlying model changes", ->
-    @formModel.set('model_field', 'haha')
-    expect( @modelForm.getValues().model_field ).toEqual 'haha'

data/spec/javascripts/components/multi_collection_view_spec.coffee

@@ -1,5 +0,0 @@
-describe 'The Collection Multi View component', ->
-  it "should share a single collection among multiple collection views", ->
-  it "should toggle visibility of one or more views", ->
-  it "should share pagination state across the multiple views", ->
-  it "should share filter state across the multiple views", ->

data/spec/javascripts/components/table_view_spec.coffee

@@ -1,17 +0,0 @@
-describe 'The Table View', ->
-  beforeEach ->
-    @tableView = new Luca.components.TableView  
-      collection: new Luca.Collection
-      columns:[
-        "column_one"
-        "column_two"
-      ]
-
-    $('body').append( @tableView.render() )
-
-  it 'should accept strings for column config', ->
-    expect( @tableView.columns[0].reader ).toEqual("column_one")
-
-  it 'should automatically determine a missing header config', ->
-    expect( @tableView.columns[0].header ).toBeDefined()
-

data/spec/javascripts/concerns/collection_event_bindings_spec.coffee

@@ -1,15 +0,0 @@
-describe 'Collection Event Bindings', ->
-  view = Luca.register("Luca.components.CollectionBindingView")
-  view.extends "Luca.View"
-  view.mixesIn  "CollectionEventBindings"
-  view.defines 
-    collection: new Luca.Collection()
-
-  xit "should allow me to bind to collection manager events"
-
-  it "should setup event relaying from the collection", ->
-    view = new Luca.components.CollectionBindingView()
-    for eventId in ["reset","add","remove","change"]
-      view.collection.trigger(eventId)
-      expect( view ).toHaveTriggered("collection:#{ eventId }")
-        

data/spec/javascripts/concerns/dom_helpers_spec.coffee

@@ -1,16 +0,0 @@
-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.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.Container()
-      expect( c.$el.is(".luca-view") ).not.toBeTruthy()
-      expect( c.$el.is(".backbone-view") ).not.toBeTruthy()

data/spec/javascripts/concerns/filterable_spec.coffee

@@ -1,25 +0,0 @@
-describe 'The Filterable Plugin', ->
-  describe 'Through the CollectionView', ->
-    beforeEach ->
-      @collection = new Luca.Collection [{name:"name"},{name:"filterable"}]
-
-      @view = new Luca.components.TableView
-        collection:@collection
-        columns:[reader:"name"] 
-
-    it 'should generate a Backbone.QueryCollection query payload', ->
-      expect( @view.getFilterState().toQuery() ).toBeDefined()
-
-    it 'should generate a Backbone.QueryCollection options payload', ->
-      expect( @view.getFilterState().toOptions() ).toBeDefined()
-
-    it "should have a toRemote method which merges params", ->
-      expect( @view.getFilterState().toRemote() ).toBeDefined()
-      
-    it 'should apply filter values', ->
-      @view.applyFilter(filter:"value")
-      expect( @view.getFilterState().toQuery().filter ).toEqual('value')
-
-    it "should trigger a refresh event on filter change", ->
-      @view.applyFilter(filter:"value")
-      expect( @view ).toHaveTriggered("data:refresh")

data/spec/javascripts/concerns/model_presenter_spec.coffee

@@ -1,31 +0,0 @@
-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/javascripts/concerns/state_model_spec.coffee

@@ -1,55 +0,0 @@
-describe 'The State Model Concern', ->
-  view = Luca.register  "Luca.components.StatefulView"
-  view.extends          "Luca.View"
-  view.mixesIn          "StateModel"
-  view.defines
-    stateful:
-      key1: "val1"
-      key2: "val2"
-
-  it "should create a state model on the view", ->
-    view = new Luca.components.StatefulView()
-    expect( view.state ).toBeDefined()
-    expect( Luca.isBackboneModel(view.state) ).toEqual true
-
-  it "should delegate the get method on the state model to the view", ->
-    view = new Luca.components.StatefulView()
-    expect( view.get ).toBeDefined()
-    expect( view.get('key1') ).toEqual 'val1' 
-
-  it "should delegate the set method on the state model to the view", ->
-    view = new Luca.components.StatefulView()
-    view.set('key1','boom') 
-    expect( view.state.get('key1') ).toEqual 'boom' 
-
-  it "should apply the default state attributes", ->
-    view = new Luca.components.StatefulView()
-    expect( view.state.toJSON() ).toEqual key1:"val1", key2: "val2"
-
-  it "should define a get/set method on the view which effect state", ->
-    view = new Luca.components.StatefulView()
-    view.set('testsetter', 'works')
-    expect( view.get('testsetter') ).toEqual('works')
-
-  describe 'State Change Event Bindings', ->
-    it "should trigger state change events on the view", ->
-      view = new Luca.components.StatefulView()
-      view.set('key1','boom')
-      expect( view ).toHaveTriggered("state:change")
-
-    it "should trigger individual attribute change events on the view", ->
-      view = new Luca.components.StatefulView()
-      view.set('key1','boom')
-      expect( view ).toHaveTriggered("state:change:key1")
-
-    it "should respond to @stateChangeEvents configuration", ->
-      view = new Luca.components.StatefulView
-        onKeyChange: sinon.spy()
-        blah: sinon.spy()
-        stateChangeEvents:
-          "key1" : "onKeyChange" 
-          "key2" : "blah"
-
-      view.set('key1','boom')
-      expect( view.blah ).not.toHaveBeenCalled()
-      expect( view.onKeyChange ).toHaveBeenCalled()

data/spec/javascripts/containers/card_view_spec.coffee

@@ -1,108 +0,0 @@
-describe "The Card View", ->
-  beforeEach ->
-    @cardView = new Luca.containers.CardView
-      visible: true
-      activeItem: 0
-      afterCardSwitch: sinon.spy()
-      beforeCardSwitch: sinon.spy()
-      components:[
-        markup: "component one"
-        name: "one"
-        one: true
-        firstActivation: sinon.spy()
-        activation: sinon.spy()
-        deactivation: sinon.spy()
-        afterInitialize: ()->
-          @on "activation", @oneSpy ||= sinon.spy()
-      ,
-        markup: "component two"
-        name: "two"
-        two: true
-        firstActivation: sinon.spy()
-        activation: sinon.spy()
-      ,
-        markup: "component three"
-        name: "three"
-        three: true
-      ]
-
-    @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
-
-  it "should start with the first component active", ->
-    expect( @cardView.activeComponent()?.name ).toEqual "one"
-
-  it "should be able to activate components by name", ->
-    @cardView.activate("two")
-    expect( @cardView.activeComponent()?.name ).toEqual "two"
-
-  it "shouldn't fire first activation on a component that hasn't been activated", ->
-    expect( @cardView.find("two")?.firstActivation ).not.toHaveBeenCalled()
-    expect( @cardView.find("two") ).not.toHaveTriggered("first:activation")
-    expect( @cardView.find("two").previously_activated ).not.toBeTruthy()
-
-  it "should fire firstActivation on a component", ->
-    @cardView.activate("two")
-    expect( @cardView.find("two") ).toHaveTriggered("first:activation")
-    expect( @cardView.find("two")?.firstActivation ).toHaveBeenCalled()
-    expect( @cardView.find("two").previously_activated ).toBeTruthy()
-
-  it "should fire deactivation on a component", ->
-    @cardView.find("one").spiedEvents = {}
-    @cardView.activate("two")
-    expect( @cardView.find("one") ).toHaveTriggered("deactivation")
-
-  it "should only fire first activation once", ->
-    @cardView.activate("two")
-    @cardView.activate("one")
-    @cardView.activate("two")
-    expect( @cardView.find("two").firstActivation.callCount ).toEqual(1)
-
-  it "should fire the first activation hook on the default card", ->
-    expect( @cardView.find("one").firstActivation.callCount ).toEqual(1)
-
-  it "should fire the activation hook on the default card", ->
-    expect( @cardView.find("one").activation.callCount ).toEqual(1)
-
-  it "should only fire the activation hook once upon activation", ->
-    @cardView.activate("two")
-    expect( @cardView.find("two").activation.callCount ).toEqual(1)
-
-  it "should only fire the deactivation hook once upon deactivation", ->
-    @cardView.activate("two")
-    expect( @cardView.find("one").deactivation.callCount ).toEqual(1)
-
-  it "should fire the beforeCardSwitch hook", ->
-    @cardView.activate("two")
-    expect( @cardView.beforeCardSwitch ).toHaveBeenCalled()
-
-  it "should fire the afterCardSwitch hook", ->
-    @cardView.activate("two")
-    expect( @cardView.afterCardSwitch ).toHaveBeenCalled()
-
-  it "should allow me to next through the cards", ->
-    @cardView.next()
-    expect(@cardView.activeComponent().name ).toEqual("two")
-
-  it "should allow me to previous through the cards", ->
-    @cardView.activate("two")
-    @cardView.previous()
-    expect(@cardView.activeComponent().name).toEqual("one")
-
-  it "should allow me to cycle through the cards", ->
-    @cardView.cycle()
-    expect(@cardView.activeComponent().name ).toEqual("two")
-    @cardView.cycle()
-    expect(@cardView.activeComponent().name ).toEqual("three")
-    @cardView.cycle()
-    expect(@cardView.activeComponent().name ).toEqual("one")

data/spec/javascripts/core/concerns_spec.coffee

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