kiss 1.1 → 1.7

data/lib/kiss/form/field_types.rb

@@ -0,0 +1,239 @@
+# Kiss Form Field types.
+
+class Kiss
+  class Form
+    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(attrs = {})
+        content_tag_html(
+          'textarea',
+          value_string,
+          attrs.merge(
+            :rows => @_rows ||= 1,
+            :cols => @_cols ||= 1
+          )
+        ) + tip_html(attrs)
+      end
+    end
+
+    class PasswordField < Field
+      def element_html(*args)
+        input_tag_html(*args)
+      end
+    end
+    
+    class FileField < Field
+      def element_html(attrs = {})
+        input_tag_html(attrs) + tip_html(attrs)
+      end
+      
+      def get_file_name; end
+  
+      def get_file_data; end
+      
+      def require_value(enter_verb)
+        p = param
+        return add_error("Please choose #{label}") unless p && p[:type]
+      end
+      
+      def validate
+        require_value(nil) if @_required
+      end
+    end
+
+    class SubmitField < Field
+      def initialize(*args)
+        @_save = false
+        super(*args)
+      end
+      
+      def element_html(*args)
+        elements_html(*args).join(' ')
+      end
+      
+      def elements_html(attrs = {})
+        @_options.map do |option|
+          input_tag_html(attrs.merge( :value => value_to_s(option) ))
+        end
+      end
+    end
+
+    # ------ MultiChoiceField
+
+    class MultiChoiceField < Field
+      def initialize(*args, &block)
+        @_options_display_transform = :to_s
+        
+        super(*args, &block)
+      end
+      
+      def option_pairs
+        pairs = if @_options_value_key
+          if @_options_display_key.is_a?(Proc)
+            @_options.map {|option| [ option[@_options_value_key], @_options_display_key.call(option) ]}
+          else
+            @_options.map {|option| [
+              option[@_options_value_key] || option.send(@_options_value_key), 
+              option[@_options_display_key] || option.send(@_options_display_key)
+            ]}
+          end
+        else
+          @_display_format = @_format
+          @_options.map {|option| [ option, option ]}
+        end
+        
+        pairs
+      end
+  
+      def has_option_value?(v)
+        !(@_options_value_key ?
+          @_options.select {|o| value_to_s(o[@_options_value_key]) == v } :
+          @_options.select {|o| value_to_s(o) == v }
+        ).empty?
+      end
+      
+      def validate
+        if @_other && param == 'other'
+          @_param = @_form.params[@_name+'.other']
+        end
+        super('select')
+        
+        if @_value =~ /\S/ && !has_option_value?(@_value)
+          add_error "Invalid selection" 
+        end
+      end
+    end
+
+    class SelectField < MultiChoiceField
+      def element_html(attrs = {})
+        return 'No options' unless @_options.size > 0
+        
+        @_choose_here ||= 'Choose Here'
+        placeholder_html = %Q(<option value="">#{@_choose_here}</option>)
+        
+        options_html = option_pairs.map do |option_value, option_display|
+          option_value_string = value_to_s(option_value)
+          selected = (value_string == option_value_string) ? ' selected' : ''
+          %Q(<option value="#{option_value_string}"#{selected}>#{display_to_s(option_display)}</option>)
+        end.join
+        
+        content_tag_html('select', placeholder_html + options_html, attrs) + other_field_html + tip_html(attrs)
+      end
+    end
+
+    class RadioField < MultiChoiceField
+      def element_html(attrs = {})
+        column_layout(elements_html(attrs)) + other_field_html + tip_html(attrs)
+      end
+      
+      def elements_html(attrs = {})
+        option_pairs.map do |option_value, option_display|
+          option_value_string = value_to_s(option_value)
+          input_tag_html(
+            attrs.merge( :type => 'radio', :value => option_value_string ),
+            (value_string == option_value_string) ? 'checked' : ''
+          ) + @_currency.to_s + display_to_s(option_display)
+        end
+      end
+    end
+
+    class BooleanField < RadioField
+      def initialize(*args, &block)
+        @_options = [[1, 'Yes'], [0, 'No']]
+        super(*args, &block)
+      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
+          return add_error("#{e.message.capitalize}")
+        end
+        
+        if @_value.empty? && @_required
+          return add_error "Please select at least one #{@_label.downcase.singularize}"
+        end
+        
+        if @_min_value_size && @_value.size < @_min_value_size
+          return add_error "Please select at least #{@_min_value_size.of(@_label.downcase)}"
+        end
+        
+        if @_max_value_size && @_value.size > @_max_value_size
+          return add_error "Please select no more than #{@_max_value_size.of(@_label.downcase)}"
+        end
+        
+        @_value.each do |v|
+          unless has_option_value?(v)
+            return add_error "Invalid selection"
+          end
+        end
+      end
+  
+      def selected_option_values
+        @_selected_option_values ||= @_value ? Hash[ *(@_value.map {|v| [value_to_s(v), true]}.flatten) ] : {}
+      end
+    end
+
+    class CheckboxField < MultiValueField
+      def element_html(attrs = {})
+        hidden_options = @_hidden_join ? input_tag_html(
+          :type => 'hidden',
+          :name => "#{@_name}_options",
+          :value => option_pairs.map {|option_value, option_display| value_to_s(option_value) }.join(@_hidden_join)
+        ) : ''
+        
+        column_layout(elements_html(attrs)) + other_field_html + hidden_options + tip_html(attrs)
+      end
+      
+      def elements_html(attrs = {})
+        name = @_name.to_s+'[]'
+        option_pairs.map do |option_value, option_display|
+          option_value_string = value_to_s(option_value)
+          
+          input_tag_html(
+            attrs.merge( :name => name, :value => option_value_string ),
+            selected_option_values[option_value_string] ? 'checked' : ''
+          ) + @_currency.to_s + display_to_s(option_display)
+        end
+      end
+    end
+
+    class MultiSelectField < MultiValueField
+      def element_html(attrs = {})
+        options_html = option_pairs.map do |option_value, option_display|
+          option_value_string = value_to_s(option_value)
+          selected = selected_option_values[option_value_string] ? ' selected' : ''
+          %Q(<option value="#{option_value_string}"#{selected}>#{display_to_s(option_display)}</option>)
+        end.join
+        
+        content_tag_html(
+          'select',
+          options_html,
+          attrs,
+          'multiple'
+        )
+      end
+    end
+    
+    # not implemented yet: MultiTextField,
+  end
+end

data/lib/kiss/format.rb

@@ -4,14 +4,13 @@ class Kiss
     # used to raise exceptions when values don't validate to format regexp
     class ValidateError < Exception; end
     
-    @regexp = //
-    @error = 'invalid format'
-    @legend = nil
-    @input_width = nil
-    @default = ''
+    @_regexp = nil
+    @_error = 'invalid format'
+    @_legend = nil
+    @_input_width = nil
     
     class << self
-      attr_accessor :regexp, :error, :legend, :input_width, :default
+      _attr_accessor :regexp, :error, :legend, :input_width
       
       # copy Format class instance variables to their subclasses
       def inherited(subclass)
@@ -20,68 +19,68 @@ class Kiss
         end
       end
       
-      def parse(value)
+      def parse(value, context = {})
         value
       end
       
-      def value_to_s(value)
+      def value_to_s(value, context = {})
         value.to_s
       end
       
-      def validate(value)
-        raise Kiss::Format::ValidateError, @error unless value.to_s =~ @regexp
-        parse(value)
+      def validate(value, context = {})
+        if !value.blank? && @_regexp && value.to_s !~ @_regexp
+          raise Kiss::Format::ValidateError, @_error
+        end
+        parse(value, context)
       end
     end
     
     class Integer < self
-      @regexp = /\A\-?\d+\Z/
-      @error = 'must be an integer'
-      @default = 0
+      @_regexp = /\A\-?\d+\Z/
+      @_error = 'must be an integer'
       
       class << self
-        def parse(value)
+        def parse(value, context = {})
           value.to_i
         end
-      
-        def validate(value)
+        
+        def validate(value, context = {})
           # remove commas for thousands
-          value =~ /\d/ ? super(value.gsub(/,/,'')) : nil
+          value.blank? ? nil : super(value.gsub(/[\$,]/, ''), context)
         end
       
-        def value_to_s(value)
+        def value_to_s(value, context = {})
           # add commas for thousands
-          value.format_thousands
+          value
         end
       end
     end
     
     class PositiveInteger < Integer
-      @regexp = /\A\d*[1-9]\d*\Z/
-      @error = 'must be a positive integer'
+      @_regexp = /\A\d*[1-9]\d*\Z/
+      @_error = 'must be a positive integer'
     end
     
     class UnsignedInteger < Integer
-      @regexp = /\A\d+\Z/
-      @error = 'must be a positive integer or zero'
+      @_regexp = /\A\d+\Z/
+      @_error = 'must be a positive integer or zero'
     end
     
     class NegativeInteger < Integer
-      @regexp = /\A\-\d*[1-9]\d*\Z/
-      @error = 'must be a negative integer'
+      @_regexp = /\A\-\d*[1-9]\d*\Z/
+      @_error = 'must be a negative integer'
     end
     
     class Decimal < Integer
-      @regexp = /\A\-?(\d+(\.\d*)?|\.\d+)\Z/
-      @error = 'must be a decimal number'
-      @default = 0
+      @_regexp = /\A\-?(\d+(\.\d*)?|\.\d+)\Z/
+      @_error = 'must be a decimal number'
       
       class << self
-        def parse(value)
+        def parse(value, context = {})
           value.to_f
         end
       
-        def value_to_s(value)
+        def value_to_s(value, context = {})
           # add commas for thousands, to integer part only
           value.format_thousands
         end
@@ -89,75 +88,93 @@ class Kiss
     end
     
     class AlphaNum < self
-      @regexp = /\A[a-z0-9]\Z/i
-      @error = 'only letters and numbers allowed'
+      @_regexp = /\A[a-z0-9]+\Z/i
+      @_error = 'only letters and numbers allowed'
     end
     
     class Word < self
-      @regexp = /\A\w+\Z/
-      @error = 'only letters, numbers, and underscores allowed'
+      @_regexp = /\A\w+\Z/
+      @_error = 'only letters, numbers, and underscores allowed'
     end
     
     class EmailAddress < self
-      @regexp = /\A[A-Z0-9._%+-]+\@([A-Z0-9-]+\.)+[A-Z]{2,4}\Z/i
-      @error = 'must be a valid email address'
-      
-      def validate(value)
-        debug 'hi'
-        super(value)
-      end
+      @_regexp = /\A[A-Z0-9._%+-]+\@([A-Z0-9\-]+\.)+[A-Z]{2,4}\Z/i
+      @_error = 'must be a valid email address'
+    end
+    
+    class URL < self
+      @_regexp = /\Ahttps?:\/\/([A-Z0-9\-]+\.)+[A-Z]{2,4}[^\"\']*\Z/i
+      @_error = 'must be a valid web address, starting with http://'
     end
     
     class DateTime < self
-      @regexp = /\A\d+\D\d+(\D\d+)?\s+\d{1,2}\:\d{2}\s*[ap]m\Z/i
-      @error = 'must be a valid date and time'
-      @legend = 'm/d/yyyy h:mm a/pm'
-      @input_width = 140
-      @default = SequelZeroTime.new('0000-00-00 00:00:00')
+      @_regexp = /\A\d+\D\d+(\D\d+)?\s+\d{1,2}(\:\d{2})?\s*[ap]m\Z/i
+      @_error = 'must be a valid date and time'
+      @_legend = 'm/d/yyyy h:mm a/pm'
+      @_input_width = 140
       
       class << self
-        def parse(value)
-          ::Time.parse(value.gsub(/[-\.]/,'/'))
+        def parse(value, context = {})
+          return nil unless value =~ /\S/
+          relative_time = context[:year] ? ::Time.parse("1/1/#{context[:year]}") : ::Time.now
+          convert_value_local_to_utc(::Time.parse(value.gsub(/[-\.]/, '/'), relative_time), context)
+        end
+        
+        def convert_value_local_to_utc(value, context)
+          if value && !value.zero? && (timezone = context[:timezone])
+            timezone = TZInfo::Timezone.get(timezone) if timezone.is_a?(String)
+            timezone.local_to_utc(value)
+          else
+            value
+          end
+        end
+        
+        def convert_value_utc_to_local(value, context)
+          if value && !value.zero? && (timezone = context[:timezone])
+            timezone = TZInfo::Timezone.get(timezone) if timezone.is_a?(String)
+            timezone.utc_to_local(value)
+          else
+            value
+          end
         end
       
-        def value_to_s(value)
-          value.strftime("%m/%d/%Y %I:%M %p").gsub(/0(\d[\:\/])/,'\1')
+        def value_to_s(value, context = {})
+          convert_value_utc_to_local(value, context).strftime("%m/%d/%Y %I:%M %p").gsub(/0(\d[\:\/])/, '\1')
         end
         
-        def validate(value)
-          value =~ /\S/ ? super(value) : nil
+        def validate(value, context = {})
+          value.blank? ? nil : super(value, context)
         end
       end
     end
     
     class Date < DateTime
-      @regexp = /\A\d+\D\d+(\D\d+)?\Z/
-      @error = 'must be a valid date'
-      @legend = 'm/d/yyyy'
-      @input_width = 80
-      @default = SequelZeroTime.new('0000-00-00')
+      @_regexp = /\A\d+\D\d+(\D\d+)?\Z/
+      @_error = 'must be a valid date'
+      @_legend = 'm/d/yyyy'
+      @_input_width = 80
       
-      def self.value_to_s(value)
+      def self.value_to_s(value, context = {})
         value.strftime("%m/%d/%Y")
       end
     end
     
     class Time < DateTime
-      @regexp = /\A\d+\:\d+\s*[ap]m\Z/i,
-      @error = 'must be a valid time'
-      @legend = 'h:mm a/pm'
-      @input_width = 80
+      @_regexp = /\A\d+\:\d+\s*[ap]m\Z/i,
+      @_error = 'must be a valid time'
+      @_legend = 'h:mm a/pm'
+      @_input_width = 80
     end
     
     class MonthYear < Date
-      @regexp = /\A\d+\D\d+\Z/
-      @error = 'must be a valid month and year (m/yyyy)'
-      @legend = 'm/yyyy'
-      @input_width = 80
+      @_regexp = /\A\d+\D\d+\Z/
+      @_error = 'must be a valid month and year (m/yyyy)'
+      @_legend = 'm/yyyy'
+      @_input_width = 80
       
       class << self
-        def parse(value)
-          month, year = value.sub(/\A\s*/,'').sub(/\s*\Z/,'').split(/\D+/)
+        def parse(value, context = {})
+          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
@@ -171,7 +188,7 @@ class Kiss
           end
         end
       
-        def value_to_s(value)
+        def value_to_s(value, context = {})
           value.strftime("%m/%Y")
         end
       end
@@ -200,6 +217,7 @@ class Kiss
       
       :email => EmailAddress,
       :email_address => EmailAddress,
+      :url => URL,
       
       :datetime => DateTime,
       :date => Date,