kiss 1.1 → 1.7

data/lib/kiss/form/field.rb

@@ -1,186 +1,259 @@
+require 'kiss/form/field';
+
 class Kiss
   class Form
     class Field
+      dsl_accessor :name, :type, :form, :currency, :label, :no_label, :prompt, :value, :read_only,
+        :ignore, :save, :options, :options_value_key, :options_display_key, :options_display_transform, 
+        :required, :unique, :cancel, :columns, :style, :hidden_join, :html, :other, :other_field, :object, 
+        :format, :display_format, :key, :match, :tip, :statement, :attach_errors, :factor, :digest,
+        :min_value_size, :max_value_size, :choose_here
+      alias_method :option_value_key, :options_value_key
+      alias_method :option_display_key, :options_display_key
+      alias_method :option_display_transform, :options_display_transform
+      alias_method :min_value_length, :min_value_size
+      alias_method :max_value_length, :max_value_size
       
-      attr_accessor :name,:type,:form,:currency,:label,:no_label,:prompt,:value,:ignore,:save,
-        :options,:options_value_key,:options_display_key,:required,:cancel,:columns,:style,:hidden_join,
-        :html,:other,:other_field,:object,:format,:display_format
+      def method_missing(method, *args, &block)
+        @_form.action.send method, *args, &block
+      end
       
-      include Kiss::Form::AttributesSetter
+      def options_keys(value, display)
+        @_options_value_key = value
+        @_options_display_key = display
+      end
+      alias_method :option_keys, :options_keys
+    
+      def debug(*args)
+        @_form.delegate.request.debug(args.first, Kernel.caller[0])
+      end
   
-      def initialize(form,attrs)
-        @form = form
-        @save = true
-        @currency = nil
+      def initialize(form, *args, &block)
+        # defaults
+        @_form = form
+        @_save = true
+        @_currency = nil
+        @_attrs = args.to_attrs
+        @_type = :text
+        @_object = @_form.object
+        @_save = true
+        @_attach_errors = true
+        
+        _instance_variables_set_from_attrs(@_attrs)
+        instance_eval(&block) if block_given?
+        
+        @_errors = []
+        
+        @_format = Kiss::Format.lookup(@_format)
+        @_display_format = Kiss::Format.lookup(@_display_format)
         
-        set_attributes({
-          :type => :text,
-          :object => @form.object,
-          :save => true
-        }.merge(attrs))
+        raise 'field must have a name' unless @_name
+        @_key ||= @_name
+        @_label ||= @_name.titleize unless @_type == :submit
         
-        @value = (@object[@name.to_sym] if @object) || @value
+        # object's value overrides any form field value
+        # form field value is intended as default in case object value is missing
+        if @_object && (value = @_object[@_key.to_sym])
+          @_value = value
+        end
+        
+        if @_currency.is_a?(Symbol)
+          @_currency = case @_currency
+          when :dollars
+            '$'
+          else
+            ''
+          end
+        end
         
-        @format = Kiss::Format.lookup(@format)
-        @display_format = Kiss::Format.lookup(@display_format)
+        if @_options
+          if @_options[0].is_a?(Array)
+            @_options_value_key ||= 0
+            (@_options_display_key ||= (@_options[0].size == 1) ? 0 : 1)
+          elsif defined?(Kiss::Model) && @_options[0].is_a?(Kiss::Model)
+            model_klass = @_options[0].class
+            @_options_value_key ||= model_klass.value_column
+            @_options_display_key ||= model_klass.display_column
+          elsif @_options[0].is_a?(Hash)
+            @_options_value_key ||= :id
+            @_options_display_key ||= :name
+          end
+        end
         
-        @currency = '$' if @currency == :dollars
+        @_tip = ((legend = @_format.legend) ? "(#{legend})" : nil) unless defined? @_tip
         
-        @errors = []
+        @_form.has_required_fields ||= @_required
       end
       
       def other_field_html
-        return '' unless @other
+        return '' unless @_other
         
-        other_checked = @value && !option_pairs.any? {|v,d| v == @value }
+        other_checked = @_value && !option_pairs.any? {|v, d| v == @_value }
         
-        (@columns ? '<br/>' : '&nbsp; ') + [
+        (@_columns ? '<br/>' : '&nbsp; ') + [
           input_tag_html(
-            { :value => 'other', :html => { :id => @name+'.other' } },
+            { :value => 'other', :html => { :id => @_name+'.other' } },
             other_checked ? 'checked' : ''
           ),
-          @other[:label] || 'Other',
+          @_other[:label] || 'Other',
           ': ',
-          @currency.to_s,
+          @_currency.to_s,
           input_tag_html({
             :type => :text,
-            :name => @name+'.other',
-            :value => other_checked ? value_to_s(@value) : nil,
+            :name => @_name+'.other',
+            :value => other_checked ? value_to_s(@_value) : nil,
             :html => {
-              :onfocus => "document.getElementById('#{@name}.other').checked = true"
+              :onfocus => "document.getElementById('#{@_name}.other').checked = true"
             }
-          }.merge(@other))
+          }.merge(@_other))
         ].join
       end
       
       def column_layout(elements_html)
-        if @columns
-          # format elements into cells
-          elements_html.map! { |el| "<td>" + el + "</td>" }
+        if elements_html.empty?
+          ''
+        elsif @_columns
+          layout_columns = [@_columns, elements_html.size].min
+          num_elements_per_column = ((elements_html.size + layout_columns - 1) / layout_columns).to_i
+          layout_columns = ((elements_html.size + num_elements_per_column - 1) / num_elements_per_column).to_i
+        
+          style = "style=\"width: #{(100 / layout_columns).to_i - 1}%\""
           
-    	    # compute height = ceiling(number of elements / columns)
-    	    height = ((elements_html.size + columns - 1)/columns).to_i
-    
-    	    # group cells into columns
-    	    element_ranges = (1..height).to_a.map {|i| ((i-1)*@columns..(i*@columns-1))}
-    	    return ['<table class="kiss_field_columns">',element_ranges.map do |range|
-    	      ["<tr>", elements_html[range], "</tr>"]
-    	    end,'</table>'].flatten.join
+          '<table class="kiss_field_columns"><tr>' +
+            (0...layout_columns).map do |i|
+              "<td #{style}>" + elements_html[i * num_elements_per_column, num_elements_per_column].join('<br/>') + "</td>"
+            end.join + '</table>'
+        else
+          elements_html.map {|h| "<nobr>#{h}</nobr>"}.join('&nbsp; ')
         end
-        
-        # else columns <= 1
-        elements_html.join('&nbsp; ')
       end
       
-      # def sequel_value
-      #   case @format
-      #   when :date:
-      #     return Kiss.mdy_to_ymd(value)
-      #   when :datetime:
-      #     datetime = value.sub(/([ap]m)\s*\Z/i,' \1')
-      #     date, time, ampm = datetime.split(/\s+/)
-      #     
-      #     hours, minutes = time.split(/:/)
-      #     hours = 0 if hours.to_i == 12 && ampm
-      #     if (ampm.downcase == 'pm')
-      #       hours = hours.to_i + 12
-      #     end
-      #     
-      #     return Kiss.mdy_to_ymd(date) + " #{hours}:#{minutes}"
-      #   when :month_year:
-      #     month, year = value.sub(/\A\s*/,'').sub(/\s*\Z/,'').split(/\D+/)
-      #     # convert two-digit years to four-digit years
-      #     year = year.to_i
-      #     if year < 100
-      #       year += 1900
-      #       year += 100 if year < Time.now.year - 95
-      #     end
-      #     return sprintf("%04d-%02d-01",year,month.to_i)
-      #   else
-      #     return value.is_a?(Array) ? value.map {|v| v.gsub(/,/,'\,')}.join(',') : value
-      #   end
-      # end
-      
       def param
-        @param ||= @form.params[@name.to_s]
+        @_param ||= @_form.params[@_name.to_s]
       end
       
       def value
-        @value
+        @_value
+      end
+      
+      def value_string
+        v = value
+        v *= @_factor if v && @_factor
+        param || value_to_s(v)
       end
       
       def add_error(message)
-        @errors << message
-        @form.has_field_errors = true
+        (@_attach_errors ? @_errors : form.errors) << message
+        @_form.has_field_errors = true
+        nil
       end
       
       def value_to_s(value)
-        value ? @format.value_to_s(value) : ''
+        value ? @_format.value_to_s(value, @_form.context) : ''
       end
       
       def display_to_s(value)
-        value ? @display_format.value_to_s(value) : ''
+        value ? @_display_format.value_to_s(value).send(@_options_display_transform) : ''
       end
       
-      def validate(enter = 'enter')
-        if @required && (param !~ /\S/)
+      def require_value(enter_verb = 'enter')
+        if (param !~ /\S/)
           # value required
-          add_error("Please #{enter} #{@label}")
+          add_error("Please #{enter_verb} #{@_label}")
           return
         end
+      end
+      
+      def reset
+        @_value = @_default_value if defined?(@_default_value)
+        @_param = nil
+      end
+      
+      def validate(enter_verb = 'enter')
+        @_default_value ||= value
+        
+        require_value(enter_verb) if @_required
         
         begin
-          @value = @format.validate(param)
+          p = @_format.validate(param, @_form.context)
+          p *= @_factor if @_factor
+          value = p
         rescue Kiss::Format::ValidateError => e
-          add_error("#{e.message.capitalize}")
+          return add_error("#{e.message.capitalize}")
+        end
+        
+        if @_match
+          match_field = @_form.fields[@_match.to_s]
+          if value != match_field.value
+            return add_error("#{match_field.label.pluralize} don't match.")
+          end
+        end
+        
+        if @_save && @_unique
+          dataset = @_object.model.filter(@_name.to_sym => value)
+          unless (@_object.new? ? dataset : dataset.exclude(@_object.pk_hash)).empty?
+            return add_error("There is already another #{@_object.model.name.singularize.gsub('_', ' ')} with the same #{@_label.downcase.gsub('_', ' ')}.")
+          end
         end
         
-        @value
+        @_value = value
       end
       
       def errors_html
-        return nil unless @errors.size > 0
+        return nil unless @_errors.size > 0
         
-        if @errors.size == 1
-          content = @errors[0]
+        if @_errors.size == 1
+          content = @_errors[0]
         else
-          content = "<ul>" + @errors.map {|e| "<li>#{e}</li>"}.join + "</ul>"
+          content = "<ul>" + @_errors.map {|e| "<li>#{e}</li>"}.join + "</ul>"
         end
         
-        %Q(<span class="#{@form.field_error_class}">#{content}</span><br clear="all" />)
+        %Q(<span class="#{@_form.field_error_class}">#{content}</span><br clear="all" />)
       end
       
-      def element_html
-        attrs = { :value => param || value_to_s(@value) }
-        if width = @format.input_width
-          attrs[:style] = "width: #{width}px"
+      def element_html(attrs = {})
+        attrs.merge!(
+          :value => value_string
+        )
+        
+        if width = @_format.input_width
+          attrs[:style] ||= "width: #{width}px"
         end
         
-        @currency.to_s + input_tag_html( attrs ) +
-          ((legend = @format.legend) ? " <small>(#{legend})</small>" : '')
+        @_currency.to_s + input_tag_html( attrs ) + tip_html(attrs)
+      end
+      
+      def table_row_html
+        form.component_html(self)
+      end
+      
+      def tip_html(attrs)
+        (tip = attrs.has_key?(:tip) ? attrs[:tip] : @_tip) ? " <small>#{tip}</small>" : ''
       end
       
-      def html
+      def html(*args)
         errors = errors_html
-        element_html + (errors ? (@columns ? '' : '<br/>') + %Q(#{errors}) : '')
+        element_html(*args) + (errors ? (@_columns ? '' : '<br/>') + %Q(#{errors}) : '')
       end
       
       def tag_start_html(tag_name, attrs = {}, extra_html = nil)
         attrs = attrs.clone
-        attrs[:name] ||= @name
-        attrs[:size] ||= @size if @size
-        attrs[:style] ||= @style if @style
+        attrs[:name] ||= @_name
+        attrs[:size] ||= @_size if @_size
+        attrs[:style] ||= @_style if @_style
+        
+        read_only = attrs.delete(:read_only) || @_read_only
         
         html_parts = ["<#{tag_name}"]
         
-        html = attrs.delete(:html) || @html
-        attrs.each_pair {|k,v| html_parts.push %Q(#{k}="#{v}") }
+        html = attrs.delete(:html) || @_html
+        attrs.each_pair {|k, v| html_parts.push %Q(#{k}="#{v}") }
         
         if html
           if html.is_a?(Hash)
-            html.each_pair {|k,v| html_parts.push %Q(#{k}="#{v}") }
+            html.each_pair {|k, v| html_parts.push %Q(#{k}="#{v}") }
           else
-            html_parts.push(@html.to_s)
+            html_parts.push(@_html.to_s)
           end
         end
         
@@ -189,222 +262,25 @@ class Kiss
       end
       
       def tag_html(tag_name, attrs = {}, extra_html = nil)
-        tag_start_html(tag_name,attrs,extra_html) + ' />'
+        return attrs[:value].html_escape.to_s.gsub(/\n/, '<br/>') if attrs[:read_only] || @_read_only
+        
+        tag_start_html(tag_name, attrs, extra_html) + ' />'
       end
       
       def content_tag_html(tag_name, content, attrs = {}, extra_html = nil)
-        tag_start_html(tag_name,attrs,extra_html) + ">#{content}</#{tag_name}>"
+        return content.to_s.html_escape.gsub(/\n/, '<br/>') if attrs[:read_only] || @_read_only
+        tag_start_html(tag_name, attrs, extra_html) + ">#{content}</#{tag_name}>"
       end
       
       def input_tag_html(attrs = {}, extra_html = nil)
         tag_html(
           'input',
-          {:type => @type}.merge(attrs),
+          {:type => @_type}.merge(attrs),
           extra_html
         )
       end
     end
-
-    class HiddenField < Field; end
-    class TextField < Field; end
-
-    class TextAreaField < Field
-      attr_accessor :rows,:cols
-      
-      def initialize(*args)
-        @rows = 5
-        @cols = 20
-        super(*args)
-      end
-      
-      def element_html
-        content_tag_html(
-          'textarea',
-          param || value_to_s(@value),
-          {
-            :rows => @rows ||= 1,
-            :cols => @cols ||= 1
-          }
-        )
-      end
-    end
-
-    class PasswordField < Field
-      def element_html
-        input_tag_html
-      end
-    end
-
-    class BooleanField < Field
-      def element_html
-        input_tag_html({ :value => 1 }, @value ? 'checked' : '')
-      end
-    end
-
-    class FileField < Field
-      def element_html
-        input_tag_html
-      end
-      
-      def get_file_name
-        
-      end
-  
-      def get_file_data
-        
-      end
-    end
-
-    class SubmitField < Field
-      def initialize(*args)
-        @save = false
-        super(*args)
-      end
-      
-      def element_html
-        elements_html.join(' ')
-      end
-      
-      def elements_html
-        @options.map do |option|
-          input_tag_html({ :value => value_to_s(option) })
-        end
-      end
-    end
-
-    # ------ MultiChoiceField
-
-    class MultiChoiceField < Field
-      def option_pairs
-        (defined? @options_value_key) ?
-          @options.map {|option| [ option[@options_value_key], option[@options_display_key] ]} :
-          begin
-            @display_format = @format
-            @options.map {|option| [ option, option ] }
-          end
-      end
-  
-      def matched_options(value)
-        value = [value].flatten
-        @options_value_key ?
-          @options.select {|o| value.select {|v| o[@options_value_key] == v } }.flatten :
-          @options.select {|o| value.select {|v| o == v } }.flatten
-      end
-  
-      def validate
-        if @other && param == 'other'
-          @param = @form.params[@name+'.other']
-        end
-        super('select')
-        
-        if @value =~ /\S/ && matched_options(@value).size == 0
-          add_error "Invalid selection" 
-        end
-      end
-    end
-
-    class SelectField < MultiChoiceField
-      def element_html
-        return 'No options' unless @options.size > 0
-        
-        placeholder_html = %Q(<option value="">Choose Here</option>)
-        
-        options_html = option_pairs.map do |value,display|
-          selected = (@value.to_s == value.to_s) ? ' selected' : ''
-          %Q(<option value="#{value_to_s(value)}"#{selected}>#{display}</option>)
-        end.join
-        
-        content_tag_html('select', placeholder_html + options_html) + other_field_html
-      end
-    end
-
-    class RadioField < MultiChoiceField
-      def element_html
-        column_layout(elements_html) + other_field_html
-      end
-  
-      def elements_html
-        option_pairs.map do |value,display|
-          input_tag_html(
-            { :value => value_to_s(value) },
-            (@value.to_s == value.to_s) ? 'checked' : ''
-          ) + @currency.to_s + display_to_s(display)
-        end
-      end
-    end
-
-
-    # ------ MultiValueField
-
-    class MultiValueField < MultiChoiceField
-      def param
-        @form.params[@name.to_s+'[]'] || []
-      end
-      
-      def validate
-        begin
-          @value = param.map { |p| @format.validate(p) }
-        rescue Kiss::Format::ValidateError => e
-          add_error("#{e.message.capitalize}")
-          return
-        end
-        
-        if @value.size > 0
-          @value.each do |v|
-            unless (matched_options(v).size > 0)
-              add_error "#Invalid selection"
-              return
-            end
-          end
-        elsif @required
-          add_error "Please select at least one #{@label}"
-        end
-      end
-  
-      def selected_option_values
-        @selected_option_values ||= @value ? Hash[ *(@value.map {|v| [v.to_s,true]}.flatten) ] : {}
-      end
-    end
-
-    class CheckboxField < MultiValueField
-      def element_html
-        hidden_options = @hidden_join ? input_tag_html(
-          :type => 'hidden',
-          :name => "#{@name}_options",
-          :value => option_pairs.map {|v,d| value_to_s(v) }.join(@hidden_join)
-        ) : ''
-        
-        column_layout(elements_html) + other_field_html + hidden_options
-      end
-      
-      def elements_html
-        name = @name.to_s+'[]'
-        option_pairs.map do |value,display|
-          input_tag_html(
-            { :name => name, :value => value_to_s(value) },
-            selected_option_values[value.to_s] ? 'checked' : ''
-          ) + @currency.to_s + display_to_s(display)
-        end
-      end
-    end
-
-    class MultiSelectField < MultiValueField
-      def element_html
-        options_html = option_pairs.map do |value,display|
-          selected = selected_option_values[value] ? ' selected' : ''
-          %Q(<option value="#{value_to_s(value)}"#{selected}>#{display}</option>)
-        end.join
-        
-        content_tag_html(
-          'select',
-          options_html,
-          {},
-          'multiple'
-        )
-      end
-    end
   end
 end
 
-# not implemented yet:
-#    :multitext => MultiTextField,
+require 'kiss/form/field_types'