luca 0.7.0 → 0.7.2

data/lib/luca/rails/version.rb

@@ -1,6 +1,6 @@
 module Luca
   module Rails
-    VERSION = "0.7.0"
+    VERSION = "0.7.2"
   end
 end
 

data/spec/components/form_view_spec.coffee

@@ -1,13 +1,201 @@
 describe 'The Form View', ->
-  describe 'Generating a form from a model', ->
-    beforeEach ->
-      Model = Backbone.Model.extend
-        schema:
-          field0: "hidden"
-          field1: "text"
-          field3: "boolean"
-          field4: "blob"
-          field5:
-            collection: "sample"
-
-      @model = new Model(field0:1,field1:"jonathan",field3:true,field4:"what up player?")
+  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?")
+
+  it "should create a form", ->
+    expect( @form ).toBeDefined()
+
+  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", ->
+    @form.render()
+    expect( @form.$el.html() ).toContain "Field Four"
+    expect( @form.$el.html() ).toContain "Field One"
+    expect( @form.$el.html() ).toContain "Click Me"
+
+  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 "Loading A New Model", ->
+    beforeEach ->
+      @form.spiedEvents = {}
+      @form.render()
+      @form.loadModel(@model)
+
+    it "should have triggered before load", ->
+      expect( @form ).toHaveTriggered("before:load")
+
+    it "should have triggered after load", ->
+      expect( @form ).toHaveTriggered("after:load")
+
+    it "should have triggered before:load:new", ->
+      expect( @form ).toHaveTriggered("before:load:new")
+
+    it "should have triggered after:load:new", ->
+      expect( @form ).toHaveTriggered("after:load:new")
+
+  describe "Loading An Existing Model", ->
+    beforeEach ->
+      @form.spiedEvents = {}
+      @form.render()
+      @model.set(id:"one")
+      @form.loadModel(@model)
+
+    it "should have triggered before:load:existing", ->
+      expect( @form ).toHaveTriggered("before:load:existing")
+
+    it "should have triggered after:load:new", ->
+      expect( @form ).toHaveTriggered("after:load:existing")
+
+    it "should apply the form values in the currentModel call if specified", ->
+      @form.getField("field1").setValue("sup baby?")
+      expect( @form.currentModel().get("field1") ).not.toEqual("sup baby?")
+      @form.getField("field1").setValue("sup baby boo?")
+      expect( @form.currentModel(refresh:false).get("field1") ).not.toEqual("sup baby boo?")
+      expect( @form.currentModel(refresh:true).get("field1") ).toEqual("sup baby boo?")
+
+  describe "The Fields Accessors", ->
+    beforeEach ->
+      @form.render()
+
+    it "should provide access to fields", ->
+      expect( @form.getFields().length ).toEqual 6
+
+    it "should allow me to access a field by its name",->
+      expect( @form.getField("field1") ).toBeDefined()
+
+  describe "The Set Values Function", ->
+    beforeEach ->
+      @form.render()
+      @form.loadModel(@model)
+
+    it "should set the values on the field", ->
+      @form.setValues({field1:"andyadontstop"})
+      expect( @form.getField("field1").getValue() ).toEqual "andyadontstop"
+
+    it "should set the values on the model", ->
+      @form.setValues(field1:"krs-one")
+      expect( @form.getField("field1").getValue() ).toEqual "krs-one"
+      expect( @model.get("field1") ).toEqual "krs-one"
+
+    it "should skip syncing with the model if passed silent", ->
+      @form.setValues({field1:"yesyesyall"},silent:true)
+      expect( @form.getField("field1").getValue() ).toEqual "yesyesyall"
+      expect( @model.get("field1") ).not.toEqual "yesyesyall"
+
+  describe "The Get Values Function", ->
+    beforeEach ->
+      @model.set(field1:"one",field2:"two",field3:undefined,field4:"")
+      @form.render()
+      @form.loadModel(@model)
+      @values = @form.getValues()
+
+    it "should skip the button fields by default", ->
+      expect( _(@values).keys() ).not.toContain("field5")
+
+    it "should include the button fields if asked", ->
+      values = @form.getValues(skip_buttons:false)
+      expect( _(values).keys() ).toContain("field5")
+
+    it "should skip blank fields by default", ->
+      values = @form.getValues()
+      expect( _(values).keys() ).not.toContain("field4")
+
+    it "should include blank fields if asked", ->
+      values = @form.getValues(reject_blank:false)
+      expect( _(values).keys() ).toContain("field4")
+
+    it "should skip blank id fields", ->
+      expect( _(@values).keys() ).not.toContain("id")
+
+  describe "Events", ->
+    beforeEach ->
+      @form.render()
+      @form.loadModel(@model)
+
+    describe "Submit Handlers", ->
+      beforeEach ->
+        @form.spiedEvents = {}
+
+      it "should trigger after submit events", ->
+        @form.submit_success_handler(@model,success:true)
+        expect( @form ).toHaveTriggered("after:submit")
+        expect( @form ).toHaveTriggered("after:submit:success")
+
+      it "should trigger after submit error events", ->
+        @form.submit_success_handler(@model,success:false)
+        expect( @form ).toHaveTriggered("after:submit")
+        expect( @form ).toHaveTriggered("after:submit:error")
+
+      it "should trigger fatal error events", ->
+        @form.submit_fatal_error_handler()
+        expect( @form ).toHaveTriggered("after:submit")
+        expect( @form ).toHaveTriggered("after:submit:fatal_error")
+
+    describe "Resetting the Form", ->
+      it "should trigger before and after reset", ->
+        @form.resetHandler(currentTarget:1)
+        expect( @form ).toHaveTriggered "before:reset"
+        expect( @form ).toHaveTriggered "after:reset"
+
+      it "should call reset", ->
+        @form.reset = sinon.spy()
+        @form.resetHandler(currentTarget:1)
+        expect( @form.reset ).toHaveBeenCalled()

data/spec/framework_spec.coffee

@@ -30,19 +30,44 @@ describe "The Luca Framework", ->
     expect(value).toEqual("haha")
 
   it "should create an instance of a class by ctype", ->
-    object = 
+    object =
       ctype: "template"
-      template: "components/form_view"    
+      template: "components/form_view"
 
     component = Luca.util.lazyComponent(object)
     expect( _.isFunction(component.render) ).toBeTruthy()
 
   it "should find a created view in the cache", ->
     template = new Luca.components.Template
-      template: "components/form_view"    
+      template: "components/form_view"
       name: 'test_template'
 
     expect(Luca.cache("test_template")).toBeDefined()
 
+  it "should detect if an object is probably a backbone view", ->
+    obj =
+      render: sinon.spy()
+      el: true
 
-describe 
+    expect( Luca.isBackboneView(obj) ).toEqual true
+    expect( Luca.isBackboneView({}) ).toEqual false
+
+  it "should detect if an object is probably a backbone collection", ->
+    obj =
+      fetch: sinon.spy()
+      reset: sinon.spy()
+
+    expect( Luca.isBackboneCollection(obj) ).toEqual true
+    expect( Luca.isBackboneCollection({}) ).toEqual false
+
+  it "should detect if an object is probably a backbone model", ->
+    obj =
+      set: sinon.spy()
+      get: sinon.spy()
+      attributes: {}
+
+    expect( Luca.isBackboneModel(obj) ).toEqual true
+    expect( Luca.isBackboneModel({}) ).toEqual false
+
+
+describe

data/src/components/form_view.coffee

@@ -1,4 +1,4 @@
-Luca.components.FormView = Luca.core.Container.extend 
+Luca.components.FormView = Luca.core.Container.extend
   tagName: 'form'
 
   className: 'luca-ui-form-view'
@@ -22,48 +22,48 @@ Luca.components.FormView = Luca.core.Container.extend
   events:
     "click .submit-button" : "submitHandler"
     "click .reset-button" : "resetHandler"
-  
+
   toolbar: true
-  
+
   initialize: (@options={})->
     Luca.core.Container::initialize.apply @, arguments
-    
-    _.bindAll @, "submitHandler", "resetHandler", "renderToolbars" 
+
+    _.bindAll @, "submitHandler", "resetHandler", "renderToolbars"
 
     @state ||= new Backbone.Model
 
     @setupHooks( @hooks )
-    
+
     @legend ||= ""
 
     @configureToolbars()
-    @applyStyles() 
+    @applyStyles()
 
   addBootstrapFormControls: ()->
     @bind "after:render", ()=>
       el = @$('.toolbar-container.bottom')
 
       el.addClass('form-controls')
-      el.html @formControlsTemplate || Luca.templates["components/bootstrap_form_controls"](@)  
+      el.html @formControlsTemplate || Luca.templates["components/bootstrap_form_controls"](@)
 
   applyStyles: ()->
     @applyBootstrapStyles() if Luca.enableBootstrap
 
     @$el.addClass( "label-align-#{ @labelAlign }") if @labelAlign
-    @$el.addClass( @fieldLayoutClass ) if @fieldLayoutClass    
+    @$el.addClass( @fieldLayoutClass ) if @fieldLayoutClass
 
   applyBootstrapStyles: ()->
     @inlineForm = true if @labelAlign is "left"
 
     @$el.addClass('well') if @well
-    @$el.addClass('form-search') if @searchForm 
-    @$el.addClass('form-horizontal') if @horizontalForm          
-    @$el.addClass('form-inline') if @inlineForm          
+    @$el.addClass('form-search') if @searchForm
+    @$el.addClass('form-horizontal') if @horizontalForm
+    @$el.addClass('form-inline') if @inlineForm
 
   configureToolbars: ()->
     return @addBootstrapFormControls() if Luca.enableBootstrap and @toolbar is true
 
-    if @toolbar is true 
+    if @toolbar is true
       @toolbars = [
         ctype: 'form_button_toolbar'
         includeReset: true
@@ -71,7 +71,7 @@ Luca.components.FormView = Luca.core.Container.extend
       ]
 
     if @toolbars and @toolbars.length
-      @bind "after:render", _.once @renderToolbars    
+      @bind "after:render", _.once @renderToolbars
 
   resetHandler: (e)->
     me = my = $( e.currentTarget )
@@ -83,17 +83,16 @@ Luca.components.FormView = Luca.core.Container.extend
     me = my = $( e.currentTarget )
     @trigger "before:submit", @
     @submit()
-  
+
   beforeLayout: ()->
     Luca.core.Container::beforeLayout?.apply @, arguments
-    @$el.html Luca.templates["components/form_view"]( @ )    
-
+    @$el.html Luca.templates["components/form_view"]( @ )
 
   prepareComponents: ()->
     container = $('.form-view-body', @el)
     _( @components ).each (component)->
       component.container = container
-  
+
   render: ()->
     $( @container ).append( @$el )
 
@@ -108,7 +107,7 @@ Luca.components.FormView = Luca.core.Container.extend
         toolbar.container = $("##{ @cid }-#{ toolbar.position }-toolbar-container")
         toolbar = Luca.util.lazyComponent(toolbar)
         toolbar.render()
-  
+
   getField: (name)->
     _( @getFields('name', name) ).first()
 
@@ -131,74 +130,102 @@ Luca.components.FormView = Luca.core.Container.extend
   loadModel: (@current_model)->
     form = @
     fields = @getFields()
-    
+
     @trigger "before:load", @, @current_model
     if @current_model
       event = "before:load:#{ (if @current_model.isNew() then "new" else "existing")}"
       @trigger event, @, @current_model
-    
-    _( fields ).each (field) =>
-      field_name = field.input_name || field.name
-      value = if _.isFunction(@current_model[ field_name ]) then @current_model[field_name].apply(@, form) else @current_model.get( field_name ) 
-      field?.setValue( value ) unless field.readOnly is true
-    
+
+    @setValues(@current_model)
+
     @trigger "after:load", @, @current_model
 
     if @current_model
       @trigger "after:load:#{ (if @current_model.isNew() then "new" else "existing")}", @, @current_model
-  
-  
-  reset: ()-> 
+
+  reset: ()->
     @loadModel( @current_model )
 
   clear: ()->
     @current_model = if @defaultModel? then @defaultModel() else undefined
 
-    _( @getFields() ).each (field)=> 
+    _( @getFields() ).each (field)=>
       try
         field.setValue('')
       catch e
         console.log "Error Clearing", @, field
 
-  getValues: (reject_blank=false,skip_buttons=true)->
+  # set the values on the form
+  # without syncing
+  setValues: (source, options={})->
+    source ||= @currentModel()
+    fields = @getFields()
+
+    _( fields ).each (field) =>
+      field_name = field.input_name || field.name
+
+      if value = source[field_name]
+        if _.isFunction(value)
+          value = value.apply(@)
+
+      if !value and Luca.isBackboneModel(source)
+        value = source.get(field_name)
+
+      field?.setValue( value ) unless field.readOnly is true
+
+    @syncFormWithModel() unless options.silent? is true
+
+  getValues: (options)->
+    options ||= {}
+
+    options.reject_blank = true unless options.reject_blank?
+    options.skip_buttons = true unless options.skip_buttons?
+
     _( @getFields() ).inject (memo,field)->
-      value = field.getValue() 
-      
+      value = field.getValue()
+      key = field.input_name || field.name
+
       skip = false
-      skip = true if skip_buttons and field.ctype is "button_field"
-      skip = true if reject_blank and _.isBlank(value)
+      skip = true if options.skip_buttons and field.ctype is "button_field"
+      skip = true if options.reject_blank is true and _.isBlank(value)
       skip = true if field.input_name is "id" and _.isBlank(value)
 
-      memo[ field.input_name || name ] = value unless skip
+      memo[ key ] = value unless skip is true
 
       memo
     , {}
-  
+
   submit_success_handler: (model, response, xhr)->
     @trigger "after:submit", @, model, response
-    
-    if response and response.success
+
+    if response and response?.success is true
       @trigger "after:submit:success", @, model, response
     else
       @trigger "after:submit:error", @, model, response
 
-  submit_fatal_error_handler: ()->
-    @trigger.apply ["after:submit", @].concat(arguments)
-    @trigger.apply ["after:submit:fatal_error", @].concat(arguments)
+  submit_fatal_error_handler: (model, response, xhr)->
+    @trigger "after:submit", @, model, response
+    @trigger "after:submit:fatal_error", @, model, response
 
-  submit: (save=true, saveOptions={})-> 
+  submit: (save=true, saveOptions={})->
     _.bindAll @, "submit_success_handler", "submit_fatal_error_handler"
 
     saveOptions.success ||= @submit_success_handler
     saveOptions.error ||= @submit_fatal_error_handler
-    
-    @current_model.set( @getValues() )
+
+    @syncFormWithModel()
     return unless save
     @current_model.save( @current_model.toJSON(), saveOptions )
 
-  currentModel: ()-> 
+  currentModel: (options={})->
+    if options is true or options?.refresh is true
+      @syncFormWithModel()
+
     @current_model
 
+  syncFormWithModel: ()->
+    @current_model?.set( @getValues() )
+
   setLegend: (@legend)->
     $('fieldset legend', @el).first().html(@legend)
 

data/src/core/view.coffee

@@ -115,6 +115,8 @@ _.extend Luca.View.prototype,
 
     @registerCollectionEvents()
 
+    @delegateEvents()
+
   $container: ()-> $(@container)
   #### Hooks or Auto Event Binding
   #

data/src/framework.coffee

@@ -1,7 +1,7 @@
 _.mixin( _.string )
 
 window.Luca =
-  VERSION: "0.7.0"
+  VERSION: "0.7.2"
   core: {}
   containers: {}
   components: {}
@@ -21,6 +21,15 @@ window.Luca =
 # problem on our own!
 Luca.enableBootstrap = true
 
+Luca.isBackboneModel = (obj)->
+  _.isFunction(obj?.set) and _.isFunction(obj?.get) and _.isObject(obj?.attributes)
+
+Luca.isBackboneView = (obj)->
+  _.isFunction(obj?.render) and !_.isUndefined(obj?.el)
+
+Luca.isBackboneCollection = (obj)->
+  _.isFunction(obj?.fetch) and _.isFunction(obj?.reset)
+
 # adds an additional namespace to look for luca ui
 # components.  useful for when you define a bunch of
 # components in your own application's namespace

data/vendor/assets/javascripts/luca-ui-base.js

@@ -3,7 +3,7 @@
   _.mixin(_.string);
 
   window.Luca = {
-    VERSION: "0.7.0",
+    VERSION: "0.7.2",
     core: {},
     containers: {},
     components: {},
@@ -22,6 +22,18 @@
 
   Luca.enableBootstrap = true;
 
+  Luca.isBackboneModel = function(obj) {
+    return _.isFunction(obj != null ? obj.set : void 0) && _.isFunction(obj != null ? obj.get : void 0) && _.isObject(obj != null ? obj.attributes : void 0);
+  };
+
+  Luca.isBackboneView = function(obj) {
+    return _.isFunction(obj != null ? obj.render : void 0) && !_.isUndefined(obj != null ? obj.el : void 0);
+  };
+
+  Luca.isBackboneCollection = function(obj) {
+    return _.isFunction(obj != null ? obj.fetch : void 0) && _.isFunction(obj != null ? obj.reset : void 0);
+  };
+
   Luca.registry.addNamespace = function(identifier) {
     Luca.registry.namespaces.push(identifier);
     return Luca.registry.namespaces = _(Luca.registry.namespaces).uniq();
@@ -408,7 +420,8 @@
         });
       }
       this.trigger("after:initialize", this);
-      return this.registerCollectionEvents();
+      this.registerCollectionEvents();
+      return this.delegateEvents();
     },
     $container: function() {
       return $(this.container);