luca 0.9.9 → 0.9.42

data/{app/assets/javascripts/luca → src}/components/fields/file_upload_field.coffee

@@ -1,11 +1,10 @@
-fileUpload = Luca.register              "Luca.fields.FileUploadField"
-fileUpload.extends                      "Luca.core.Field"
-
-fileUpload.defines
-  version: 1
+_.def('Luca.fields.FileUploadField').extends('Luca.core.Field').with
 
   template: 'fields/file_upload_field'
 
+  initialize: (@options={})->
+    Luca.core.Field::initialize.apply @, arguments
+
   afterInitialize: ()->
     @input_id ||= _.uniqueId('field')
     @input_name ||= @name

data/src/components/fields/hidden_field.coffee

@@ -0,0 +1,12 @@
+_.def('Luca.fields.HiddenField').extends('Luca.core.Field').with
+
+  template: 'fields/hidden_field'
+
+  initialize: (@options={})->
+    Luca.core.Field::initialize.apply @, arguments
+
+  afterInitialize: ()->
+    @input_id ||= _.uniqueId('field')
+    @input_name ||= @name
+    @input_value ||= @value
+    @label ||= @name

data/src/components/fields/label_field.coffee

@@ -0,0 +1,14 @@
+_.def("Luca.components.LabelField").extends("Luca.core.Field").with
+  className: "luca-ui-field luca-ui-label-field"
+    
+  getValue: ()->
+    @$('input').attr('value')
+
+  formatter: (value)->
+    value ||= @getValue()
+    _.str.titleize( value )
+
+  setValue: (value)->
+    @trigger("change", value, @getValue())
+    @$('input').attr('value', value)
+    @$('.value').html( @formatter(value) )

data/src/components/fields/select_field.coffee

@@ -0,0 +1,97 @@
+_.def('Luca.fields.SelectField').extends('Luca.core.Field').with
+
+  events:
+    "change select" : "change_handler"
+
+  hooks:[
+    "after:select"
+  ]
+
+  className: 'luca-ui-select-field luca-ui-field'
+
+  template: "fields/select_field"
+
+  includeBlank: true
+
+  blankValue: ''
+
+  blankText: 'Select One'
+
+  initialize: (@options={})->
+    _.extend @, @options
+    _.extend @, Luca.modules.Deferrable
+    _.bindAll @, "change_handler", "populateOptions", "beforeFetch"
+
+    Luca.core.Field::initialize.apply @, arguments
+
+    @input_id ||= _.uniqueId('field')
+    @input_name ||= @name
+    @label ||= @name
+    @retainValue = true if _.isUndefined @retainValue
+
+  afterInitialize: ()->
+    if @collection?.data
+      @valueField ||= "id"
+      @displayField ||= "name"
+      @parseData()
+
+    try
+      @configure_collection()
+    catch e
+      console.log "Error Configuring Collection", @, e.message
+
+    @collection.bind "before:fetch", @beforeFetch
+    @collection.bind "reset", @populateOptions
+
+  # if the select field is configured with a data property
+  # then parse that data into the proper format.  either
+  # an array of objects with the valueField and displayField
+  # properties, or an array of arrays with [valueField, displayField]
+  parseData: ()->
+    @collection.data = _( @collection.data ).map (record)=>
+      return record if not _.isArray( record )
+
+      hash = {}
+      hash[ @valueField ] = record[0]
+      hash[ @displayField ] = record[1] || record[0]
+
+      hash
+
+  afterRender: ()->
+    @input = $('select', @el)
+
+    if @collection?.models?.length > 0
+      @populateOptions()
+    else
+      @collection.trigger("reset")
+
+  setValue: (value)->
+    @currentValue = value
+    Luca.core.Field::setValue.apply @, arguments
+
+  beforeFetch: ()->
+    @resetOptions()
+
+  change_handler: (e)->
+    @trigger "on:change", @, e
+
+  resetOptions: ()->
+    @input.html('')
+
+    if @includeBlank
+      @input.append("<option value='#{ @blankValue }'>#{ @blankText }</option>")
+
+
+  populateOptions: ()->
+    @resetOptions()
+
+    if @collection?.each?
+      @collection.each (model) =>
+        value = model.get( @valueField )
+        display = model.get( @displayField )
+        selected = "selected" if @selected and value is @selected
+        option = "<option #{ selected } value='#{ value }'>#{ display }</option>"
+        @input.append( option )
+
+    @trigger "after:populate:options", @
+    @setValue( @currentValue )

data/src/components/fields/text_area_field.coffee

@@ -0,0 +1,40 @@
+_.def('Luca.fields.TextAreaField').extends('Luca.core.Field').with
+
+  events:
+    "keydown input" : "keydown_handler"
+    "blur input" : "blur_handler"
+    "focus input" : "focus_handler"
+
+  template: 'fields/text_area_field'
+
+  height: "200px"
+  width: "90%"
+
+  initialize: (@options={})->
+    _.bindAll @, "keydown_handler"
+
+    Luca.core.Field::initialize.apply @, arguments
+
+    @input_id ||= _.uniqueId('field')
+    @input_name ||= @name
+    @label ||= @name
+    @input_class ||= @class
+    @inputStyles ||= "height:#{ @height };width:#{ @width }"
+
+  setValue: (value)->
+    $( @field() ).val(value)
+
+  getValue: ()->
+    $( @field() ).val()
+
+  field: ()->
+    @input = $("textarea##{ @input_id }", @el)
+
+  keydown_handler: (e)->
+    me = my = $( e.currentTarget )
+
+  blur_handler: (e)->
+    me = my = $( e.currentTarget )
+
+  focus_handler: (e)->
+    me = my = $( e.currentTarget )

data/{app/assets/javascripts/luca → src}/components/fields/text_field.coffee

@@ -1,8 +1,6 @@
-textField = Luca.register     'Luca.fields.TextField'
-textField.extends             'Luca.core.Field'
 
-textField.defines
-  _inheritEvents:
+_.def('Luca.fields.TextField').extends('Luca.core.Field').with
+  events:
     "blur input" : "blur_handler"
     "focus input" : "focus_handler"
     "change input" : "change_handler"
@@ -17,33 +15,24 @@ textField.defines
 
   initialize: (@options={})->
     if @enableKeyEvents
-      if @keyEventThrottle
-        @keyup_handler = _.debounce(@keyup_handler, @keyEventThrottle)
-        
       @registerEvent("keyup input","keyup_handler")     
 
     @input_id ||= _.uniqueId('field')
     @input_name ||= @name
     @label ||= @name
     @input_class ||= @class
-    @input_value ||= @value || "" 
-    
+
     if @prepend
-      @$el.addClass 'input-prepend'
+      @$el.addClass('input-prepend')
       @addOn = @prepend
 
     if @append
-      @$el.addClass 'input-append'
+      @$el.addClass('input-append')
       @addOn = @append
 
-    @placeHolder ||= ""
-
     Luca.core.Field::initialize.apply @, arguments
 
   keyup_handler: (e)->
-    # TODO: Should ignore certain keyup events
-    # which would not indicate a change
-    @trigger "on:change", @, e
     @trigger "on:keyup", @, e
 
   blur_handler: (e)->

data/src/components/fields/type_ahead_field.coffee

@@ -0,0 +1,22 @@
+_.def('Luca.fields.TypeAheadField').extends('Luca.fields.TextField').with
+  className: 'luca-ui-field'
+
+  getSource: ()->
+    return @source.call(@) if _.isFunction(@source)
+    @source || []
+
+  matcher: (item)->
+    # IMPLEMENT
+    # return true where item matches @query
+    true
+
+  beforeRender: ()->
+    @_super("beforeRender", @, arguments)
+    @$('input').attr('data-provide','typeahead')
+
+  afterRender: ()->
+    @_super("afterRender", @, arguments)
+
+    @$('input').typeahead
+      matcher: @matcher
+      source: @getSource()

data/src/components/form_button_toolbar.coffee

@@ -0,0 +1,25 @@
+_.def('Luca.components.FormButtonToolbar').extends('Luca.components.Toolbar').with
+
+  className: 'luca-ui-form-toolbar form-actions'
+
+  position: 'bottom'
+
+  includeReset: false
+
+  render: ()->
+    $(@container).append(@el)
+
+  initialize: (@options={})->
+    Luca.components.Toolbar.prototype.initialize.apply @, arguments
+
+    @components = [
+      ctype: 'button_field'
+      label: 'Submit'
+      class: 'btn submit-button'
+    ]
+
+    if @includeReset
+      @components.push
+        ctype: 'button_field'
+        label: 'Reset'
+        class: 'btn reset-button'

data/src/components/form_view.coffee

@@ -0,0 +1,275 @@
+defaultToolbar =
+  buttons:[
+    icon:"remove-sign"
+    label: "Reset"
+    eventId: "click:reset"
+    className:"reset-button"
+    align: 'right'
+  ,
+    icon:"ok-sign"
+    white: true
+    label: "Save Changes"
+    eventId: "click:submit"
+    color: "success"
+    className: 'submit-button'
+    align: 'right'
+  ]
+
+_.def("Luca.components.FormView").extends('Luca.core.Container').with
+
+  tagName: 'form'
+
+  className: 'luca-ui-form-view'
+
+  hooks:[
+    "before:submit"
+    "before:reset"
+    "before:load"
+    "before:load:new"
+    "before:load:existing"
+    "after:submit"
+    "after:reset"
+    "after:load"
+    "after:load:new"
+    "after:load:existing"
+    "after:submit:success"
+    "after:submit:fatal_error"
+    "after:submit:error"
+  ]
+
+  events:
+    "click .submit-button" : "submitHandler"
+    "click .reset-button" : "resetHandler"
+
+  toolbar: true
+
+  legend: ""
+
+  bodyClassName: "form-view-body"
+
+  version: "0.9.33333333"
+
+  initialize: (@options={})->
+    @loadMask = Luca.enableBootstrap unless @loadMask?
+
+    Luca.core.Container::initialize.apply @, arguments
+
+    _.bindAll @, "submitHandler", "resetHandler", "renderToolbars", "applyLoadMask"
+
+    @state ||= new Backbone.Model
+
+    @setupHooks( @hooks )
+
+    @applyStyleClasses()
+
+    if @toolbar isnt false and (not @topToolbar and not @bottomToolbar)
+      @topToolbar = @getDefaultToolbar() if @toolbar is "both" or @toolbar is "top"
+      @bottomToolbar = @getDefaultToolbar() unless @toolbar is "top"
+
+  getDefaultToolbar: ()->
+    defaultToolbar
+
+  applyStyleClasses: ()->
+    if Luca.enableBootstrap
+      @applyBootstrapStyleClasses()
+
+    @$el.addClass( "label-align-#{ @labelAlign }") if @labelAlign
+    @$el.addClass( @fieldLayoutClass ) if @fieldLayoutClass
+
+  applyBootstrapStyleClasses: ()->
+    @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
+
+  resetHandler: (e)->
+    me = my = $( e?.target )
+    @trigger "before:reset", @
+    @reset()
+    @trigger "after:reset", @
+
+  submitHandler: (e)->
+    me = my = $( e?.target )
+    @trigger "before:submit", @
+    @trigger "enable:loadmask", @ if @loadMask is true
+    @submit() if @hasModel()
+
+  afterComponents: ()->
+    Luca.core.Container::afterComponents?.apply(@, arguments)
+
+    @eachField (field)=>
+      field.getForm = ()=> @
+      field.getModel = ()=> @currentModel()
+
+  eachField: (iterator)->
+    _( @getFields() ).map( iterator )
+
+  getField: (name)->
+    passOne = _( @getFields('name', name) ).first()
+    return passOne if passOne?
+
+    _( @getFields('input_name', name) ).first() 
+
+  getFields: (attr,value)->
+    fields = @selectByAttribute("isField", true, true)
+
+    if attr? and value?
+      fields = _(fields).select (field)->
+        property  = field[ attr ]
+        property  = property.call(field) if _.isFunction(property)
+        property is value
+
+    fields
+
+  loadModel: (@current_model)->
+    form = @
+    fields = @getFields()
+
+    @trigger "before:load", @, @current_model
+
+    if @current_model
+      @current_model.beforeFormLoad?.apply(@current_model, @)
+
+      event = "before:load:#{ (if @current_model.isNew() then "new" else "existing")}"
+      @trigger event, @, @current_model
+
+    @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: ()->
+    @loadModel( @current_model ) if @current_model?
+
+  clear: ()->
+    @current_model = if @defaultModel? then @defaultModel() else undefined
+
+    _( @getFields() ).each (field)=>
+      try
+        field.setValue('')
+      catch e
+        console.log "Error Clearing", @, field
+
+  # 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
+
+  # Public: returns a hash of values for the form fields in this view.
+  #
+  # options - An options Hash to control the behavior of values returned (default: {}):
+  #           reject_blank: don't include values which are blank (default: true)
+  #           skip_buttons: don't include button fields (default: true)
+  #           blanks: an inverse alias for reject_blank (default: false)
+  getValues: (options={})->
+    options.reject_blank = true unless options.reject_blank?
+    options.skip_buttons = true unless options.skip_buttons?
+    options.reject_blank = true if options.blanks is false
+
+    values = _( @getFields() ).inject (memo,field)=>
+      value   = field.getValue()
+      key     = field.input_name || field.name
+
+      valueIsBlank      = !!(_.str.isBlank( value ) || _.isUndefined( value ))
+
+      allowBlankValues  = not options.reject_blank and not field.send_blanks
+
+      if options.debug
+        console.log "#{ key } Options", options, "Value", value, "Value Is Blank?", valueIsBlank, "Allow Blanks?", allowBlankValues
+
+      if options.skip_buttons and field.ctype is "button_field"
+        skip = true
+      else
+        if valueIsBlank and allowBlankValues is false 
+          skip = true 
+
+        if field.input_name is "id" and valueIsBlank is true
+          skip = true
+
+      if options.debug
+        console.log "Skip is true on #{ key }"
+        
+      if skip isnt true
+        memo[ key ] = value 
+
+      memo
+
+    , (options.defaults || {})
+
+    values
+
+  submit_success_handler: (model, response, xhr)->
+    @trigger "after:submit", @, model, response
+    @trigger "disable:loadmask", @ if @loadMask is true
+
+    if response and response?.success is true
+      @trigger "after:submit:success", @, model, response
+    else
+      @trigger "after:submit:error", @, model, response
+
+  submit_fatal_error_handler: (model, response, xhr)->
+    @trigger "after:submit", @, model, response
+    @trigger "after:submit:fatal_error", @, model, response
+
+  submit: (save=true, saveOptions={})->
+    _.bindAll @, "submit_success_handler", "submit_fatal_error_handler"
+
+    saveOptions.success ||= @submit_success_handler
+    saveOptions.error ||= @submit_fatal_error_handler
+
+    @syncFormWithModel()
+    return unless save
+    @current_model.save( @current_model.toJSON(), saveOptions )
+
+  hasModel: ()->
+    @current_model?
+
+  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)
+
+  flash: (message)->
+    if @$('.toolbar-container.top').length > 0
+      @$('.toolbar-container.top').after(message)
+    else
+      @$bodyEl().prepend(message)
+
+  successFlashDelay: 1500
+
+  successMessage: (message)->
+    @$('.alert.alert-success').remove()
+    @flash Luca.template("components/form_alert", className:"alert alert-success", message: message)
+    _.delay ()=>
+      @$('.alert.alert-success').fadeOut()
+    , @successFlashDelay || 0
+
+  errorMessage: (message)->
+    @$('.alert.alert-error').remove()
+    @flash Luca.template("components/form_alert", className:"alert alert-error", message: message)