kiss 1.1 → 1.7

data/lib/kiss/ext/rack.rb

@@ -0,0 +1,33 @@
+module Rack
+  autoload :Bench, 'kiss/rack/bench'
+  autoload :ErrorsOK, 'kiss/rack/errors_ok'
+  autoload :EmailErrors, 'kiss/rack/email_errors'
+  autoload :Facebook, 'kiss/rack/facebook'
+  autoload :FileNotFound, 'kiss/rack/file_not_found'
+  autoload :LogExceptions, 'kiss/rack/log_exceptions'
+  autoload :Recorder, 'kiss/rack/recorder'
+  autoload :ShowDebug, 'kiss/rack/show_debug'
+  autoload :ShowExceptions, 'kiss/rack/show_exceptions'
+  
+  class Request
+    def server
+      url = scheme + "://"
+      url << host
+
+      if scheme == "https" && port != 443 ||
+          scheme == "http" && port != 80
+        url << ":#{port}"
+      end
+      
+      url
+    end
+  end
+  
+  class Response
+    def prepend_html(*args)
+      b = body
+      (b = b.join) if b.is_a?(Array)
+      b.prepend_html(*args)
+    end
+  end
+end

data/lib/kiss/ext/sequel_database.rb

@@ -0,0 +1,47 @@
+class Kiss
+  # This module is included into Sequel database class to provide Kiss-specific
+  # fnctionality to database objects.
+  module SequelDatabase
+    
+    def self.append_features(mod)
+      mod.class_eval do
+        alias_method :execute_old, :execute
+        _attr_accessor :kiss_controller, :kiss_request, :kiss_model_cache
+        
+        def execute(sql, *args, &block)   #:nodoc:
+          @_last_query = sql
+          execute_old(sql, *args, &block)
+        end
+      end
+      super
+    end
+  
+    @_last_query = nil
+    def last_query   #:nodoc:
+      @_last_query
+    end
+    
+      # Returns Sequel dataset to evolution_number table, which specifies 
+      # app's current evolution number.
+    # Creates evolution_number table if it does not exist.
+    def evolution_number_table
+      unless self.table_exists?(:evolution_number)
+        self.create_table :evolution_number do
+          column :version, :integer, :null=> false
+        end
+        self[:evolution_number].insert(:version => 0)
+      end
+      self[:evolution_number]
+    end
+
+    # Returns app's current evolution number.
+    def evolution_number
+      evolution_number_table.first.version
+    end
+
+    # Sets app's current evolution number.
+    def evolution_number=(version)
+      evolution_number_table.update(:version => version)
+    end
+  end
+end

data/lib/kiss/ext/sequel_mysql_dataset.rb

@@ -0,0 +1,23 @@
+class Kiss
+  module SequelMySQLDataset
+    # Returns results from dataset query as array of arrays,
+    # instead of array of hashes. 
+    def all_arrays(opts = nil, &block)
+      a = []
+      fetch_arrays(select_sql()) {|r| a << r}
+      a.each(&block) if block
+      a
+    end
+    
+    # Fixes bug in Sequel 1.5; shouldn't be needed for Sequel 2.x
+    # (need to double-check, however).
+    def fetch_arrays(sql)
+      execute(sql) do |r|
+        while row = r.fetch_row
+          yield row
+        end
+      end
+      self
+    end
+  end
+end

data/lib/kiss/form.rb

@@ -1,146 +1,228 @@
-module Digest; end
+require 'kiss/form/field';
 
-class Kiss
-  class Form
-    module AttributesSetter
-      def set_attributes(attrs_original,required = [])
-        unless attrs_original.is_a?(Hash) then
-          raise "first parameter must be a hash of attributes: #{attrs_original}"
-        end
-    
-        attrs = attrs_original.clone
-    
-        required.each do |key|
-          raise "missing required parameter '#{key}'" unless attrs[key]
-          send("#{key}=", attrs[key])
-          attrs.delete(key)
-        end
-    
-        attrs.each_pair do |key,value|
-          send("#{key}=", value)
-        end
-      end
-    end
-    include Kiss::Form::AttributesSetter
+# Part Hash, part Array... it's a Hashay.
+class Hashay < Hash
+  _attr_accessor :keys, :values
   
-    require 'kiss/form/field';
+  def initialize(*args, &block)
+    super
+    @_keys = []
+    @_values = []
+  end
   
-    attr_accessor :name,:params,:submitted,:action,:controller,:id,:url,:request,
-      :object,:fields,:fields_hash,:method,:enctype,:errors,:submit,:cancel,:style,
-      :has_field_errors,:error_class,:field_error_class,:mark_required,:object, :html
+  def each_key(&block)
+    @_keys.each &block
+  end
   
+  def each_value(&block)
+    @_values.each &block
+  end
+  alias_method :each, :each_value
   
-    @@field_types = {
+  def []=(key, value)
+    unless has_key?(key)
+      @_keys << key
+      @_values << value 
+    end
+    super
+  end
+  
+  def [](key)
+    key.is_a?(Numeric) ? @_values[key] : super
+  end
+  
+  include Enumerable
+end
+
+class Kiss
+  class Form
+    _attr_accessor :fields, :params, :submitted, :has_field_errors, :has_required_fields,
+      :delegate, :controller, :components, :form, :new_object_index
+    dsl_accessor :name, :url, :action, :method, :enctype, :errors, :cancel, :mark_required,
+      :id, :class, :style, :html, :error_class, :field_error_class, :objects_save_order,
+      :object, :prepend_html, :append_html, :year, :timezone
+    
+    @@component_types = {
       :text => TextField,
       :hidden => HiddenField,
       :textarea => TextAreaField,
       :password => PasswordField,
-      #:multitext => MultiTextField,
       :boolean => BooleanField,
       :file => FileField,
       :select => SelectField,
       :radio => RadioField,
       :checkbox => CheckboxField,
       :multiselect => MultiSelectField,
-      :submit => SubmitField,
+      :submit => SubmitField
     }
+      
+    # Create DSL methods for component types
+    self.class_eval(
+      @@component_types.keys.map do |type|
+        "def #{type}(*args, &block); add_component(:#{type}, *args, &block); end; "
+      end.join
+    )
+    
+    def add_component(type, name, *args, &block)
+      attrs = args.to_attrs
+      add_field({
+        :type => type,
+        :name => name
+      }.merge(attrs), &block)
+    end
     
+    def debug(*args)
+      @_delegate.request.debug(args.first, Kernel.caller[0])
+    end
     
-    # Creates a new form object with specified attributes.
-    def initialize(attrs)
-      set_attributes(attrs,[:name,:action])
-    
-      raise "Missing required option 'name'" unless @name && (@name != '')
-    
-      @method ||= 'post'
+    def method_missing(method, *args, &block)
+      delegate.send method, *args, &block
+    end
     
-      # move field definitions to different var
-      # want to use @fields for array of Field objects
-      @fields_specs = @fields || []
+    def unique(*val)
+      if val.empty?
+        @_unique
+      else
+        @_unique << val
+      end
+    end
     
-      @fields = []
-      @fields_hash = {}
-      @default_values ||= {}
-      @params = {}
+    # Creates a new form object with specified attributes.
+    def initialize(*args, &block)
+      @_attrs = args.to_attrs
+      _instance_variables_set_from_attrs(@_attrs)
     
-      @fields_specs.each do |field|
+      @_method ||= 'post'
+      
+      @_components = []
+      @_fields = Hashay.new
+      @_object_fields = {}
+      @_default_values ||= {}
+      @_params = {}
+      @_with = nil
+      @_field_name_prefix = ''
+      @_objects_add_order = []
+      @_objects_save_order = []
+      @_new_object_index = -1
+      @_object_fields = {}
+      @_unique = []
+      
+      @_prepend_html = ''
+      @_append_html = ''
+      
+      (@_attrs[:fields] || []).each do |field|
         # create field here
         add_field(field)
       end
       
-    	@errors = []
-    	@field_errors = {}
+    	@_errors = []
+    	@_field_errors = {}
+    	
+      import_instance_variables(@_delegate) if @_delegate
+      
+      instance_eval(&block) if block_given?
+      
+      raise "form name required" unless @_name
+      raise "form delegate required" unless @_delegate
     end
     
-    # Adds a section break, which causes form's table to close and new table to open when form is rendered.
-    def add_section_break
-      @fields << :section_break
+    def context
+      @_context ||= begin
+        @_timezone ||= (fields['timezone'] && (params['timezone'] || (object && object[:timezone]))) || nil
+        {
+          :timezone => @_timezone,
+          :year => @_year
+        }
+      end
     end
     
-    def create_field(attrs)
-      raise "form already has field named '#{attrs[:name]}'" if @fields_hash[attrs[:name]]
+    # Creates and adds a field to the form, according to specified attributes.
+    def add_field(attrs = {}, &block)
+      attrs = @_with.merge(attrs) if @_with
+      name = attrs[:name].to_s
+      key = (attrs[:key] || name).to_sym
+      
+      name = @_field_name_prefix + name unless @_field_name_prefix.empty?
+      
+      type = attrs[:type] ? attrs[:type].to_sym : :text
+      raise "invalid field type '#{type}'" unless @@component_types.has_key?(type)
       
-      attrs[:type] ||= :text
-      type = attrs[:type].to_sym
-      type = attrs[:type] = :text unless @@field_types.has_key?(type)
+      field = @@component_types[type].new(self, attrs.merge(
+        :name => name,
+        :key => key,
+        :type => type
+      ), &block)
       
-      field_class = @@field_types[type]
-      field = field_class.new(self,attrs)
+      field.object = @_object if @_object && !field.object
+      obj = field.object
+      # must hash @_object_fields by Ruby object id; if by object, weird lookup errors result,
+      # even when lookup object has same Ruby object id as the hash key object!
+      ruby_obj_id = obj.object_id
+      unless @_object_fields[ruby_obj_id]
+        @_object_fields[ruby_obj_id] = {}
+        @_objects_add_order << object
+      end
+      if @_object_fields[ruby_obj_id][field.name]
+        raise "duplicate form field name '#{attrs[:name]}'#{" on #{obj.class.name} object" if obj}"
+      end
+      @_object_fields[ruby_obj_id][field.name] = field
       
-      field_name = field.name.to_s
-      field.form = self
+      @_fields[name] = field
+      @_components << field
       
       while true
         other_field = field.other_field
         break unless other_field
         other_field.form = self
-        @other_field = @form.create_field( { :name => @name + '.other' }.merge(@other) )
+        @_other_field = @_form.create_field( { :name => @_name + '.other' }.merge(@_other) )
       end
       
-      @fields_hash[field_name] = field
-      
-      @enctype = 'multipart/form-data' if field.type == :file
+      @_enctype = 'multipart/form-data' if field.type == :file
       
       field
     end
+    alias_method :create_field, :add_field
     
-    # Creates and adds a field to the form, according to specified attributes.
-    def add_field(attrs)
-      # create field
-      field = create_field(attrs)
-      
-      # used with mark_required to display required fields legend
-      @has_required_fields ||= attrs[:required]
-      
-      # add field to form array/hash
-      @fields << field
-      
-      field
+    # Creates and adds set of submit buttons to the form, per specified attributes.
+    def submit(*args, &block)
+      if args.size > 0
+        raise 'submit already defined' if @_submit
+        
+        attrs = {
+          :type => :submit,
+          :name => 'submit',
+          :save => false,
+          :cancel => 'Cancel'
+        }
+        attrs.merge!(args.pop) if args.last.is_a?(Hash)
+        attrs[:options] = args if args.size > 0
+        attrs = @_with.merge(attrs) if @_with
+        @_submit = @@component_types[:submit].new(self, attrs, &block)
+      else
+        @_submit
+      end
     end
+    alias_method :add_submit, :submit
     
-    # Creates and adds set of submit buttons to the form, per specified attributes.
-    def add_submit(attrs)
-      @submit = create_field({
-        :type => :submit,
-        :name => 'submit',
-        :save => false
-      }.merge(attrs) )
-    end
-    
-    # Gets hash of form values ready to be saved to Sequel::Model object.
-    # def sequel_values
-    #   @sequel_values ||= begin
-    #     hash = {}
-    #     @fields.each {|field| hash[field.name] = field.sequel_value unless field == :section_break }
-    #     hash
-    #   end
-    # end
+    def reset
+      @_params = {}
+    	@_fields.each {|field| field.reset }
+    end
+    
+    def field(name)
+      @_fields[name]
+    end
+    
+    def object_field(obj, name)
+      @_object_fields[obj.object_id][name.to_s]
+    end
     
     # Gets hash of form values.
     def values
-      @values ||= begin
+      @_values ||= begin
         hash = {}
-        @fields.each {|field| hash[field.name] = field.value unless field == :section_break}
+        @_fields.each {|field| hash[field.name] = field.value }
+        hash['submit'] = @_submit.value = params[@_submit.name.to_s]
         hash
       end
     end
@@ -149,27 +231,26 @@ class Kiss
     # If multiple args given, first arg is field name, and second arg (error message)
     # will render next to specified field.
     def add_error(*args)
-      if args.size > 2
-        raise 'too many args'
-      elsif args.size == 0
-        raise 'at least one arg required'
-      end
-      
-      # args.size == 1 or 2
-      if args.size == 1
-        if args[0].is_a?(String)
-          @errors << args[0]
-          return
+      case args.size
+      when 0
+        raise 'at least one argument required'
+      when 1
+        arg = args.first
+        if arg.is_a?(Hash)
+          field = arg.field || arg.field_name
+          message = arg.message
         else
-          field_name = args[0].field_name.to_s
-          message = args[0].message
+          @_errors << arg
+          return
         end
-      else # args.size == 2
-        # args == [field_name, message]
-        field_name = args[0].to_s
-        message = args[1]
+      when 2
+        field, message = args
+      else
+        raise 'too many arguments'
       end
-      return @fields_hash[field_name].add_error(message)
+      
+      field = @_fields[field] if field.is_a?(String)
+      field.add_error(message)
     end
     
     # Validates form values against fields' format and required attributes,
@@ -177,92 +258,211 @@ class Kiss
     def validate
       return nil unless submitted
       
-    	@fields.each {|field| field.validate unless field == :section_break }
+    	@_fields.each {|field| field.validate }
+    	@_unique.each {|field_set| validate_uniqueness_of(field_set) }
   	  
-  	  has_errors ? nil : values
+  	  has_errors? ? nil : values
     end
     
-    # Saves form values to Sequel::Model object.
-    def save(object = @object)
-      @fields.each do |field|
-        next if field == :section_break
-    		# ignore fields whose name starts with underscore
-        next if field.name =~ /\A\_/
-    		# don't save 'ignore' fields to the database
-        next if field.ignore || !field.save
-        
-        value = (field.value != nil || object.class.db_schema[field.name.to_sym].allow_null) ?
-          field.value : (object.class.db_schema[field.name.to_sym][:default] ||= field.format.default)
-        
-        object[field.name.to_sym] = field.save == true ? value :
-          (digest_class = Kiss.digest_class(field.save)) ? digest_class.hexdigest(value) : value
+    def validate_uniqueness_of(column_set)
+      column_set_labels_values = column_set.map do |column_name|
+        (field = fields[column_name.to_s]) ? 
+          [field.label, field.value] : 
+          [column_name.to_s.sub(/_id\Z/, '').titlecase, object[column_name]]
       end
+      conditions = column_set.zip column_set_labels_values.map {|lv| lv[1] }
       
-      object.save
-    end
-    
-    # Returns true if form has errors.
-    def has_errors
-      (@errors.size > 0 || @has_field_errors)
+      dataset = @_object.model.filter(conditions)
+      unless (@_object.new? ? dataset : dataset.exclude(@_object.pk_hash)).empty?
+        labels = column_set_labels_values.map {|lv| lv[0] }
+        message = "There is already another #{@_object.model.name.singularize.gsub('_', ' ')} with the same #{labels.conjoin}."
+        return (
+          (column_set.length == 1) && 
+          (field_name = column_set[0].to_str) &&
+          fields[field_name]
+        ) ? add_error(field_name, message) : add_error(message)
+      end
     end
     
     # Checks whether form was submitted and accepted by user and, if so,
     # whether form validates.
     # If form validates, saves form values to form's Sequel::Model object 
     # and returns true.  Otherwise, returns false.
-    def process(object = @object)
+    def process(*objs)
       return false unless submitted
       
       if accepted
         validate
-        return false if has_errors
+        return false if has_errors?
       
-        save(object)
+        save(*objs)
       end
   	  
     	return true
     end
     
+    def process_or_render
+      self.render unless self.process
+    end
+    
+    private
+    
+    def extract_objects_from_args(objs)
+      objs = args.first if objs.first.is_a?(Array)
+      if objs.size == 0
+        objects_save_order.push(@_object) if @_object && !objects_save_order.include?(@_object)
+        objs = objects_save_order
+      end
+      objs
+    end
+    
+    public
+    
+    def set_object_data(obj = @_object)
+      @_object_fields[obj.object_id].values.each do |field|
+    		# ignore fields whose name starts with underscore
+        next if field.name =~ /\A\_/
+    		# don't save 'ignore' fields to the database
+        next if field.ignore || !field.save
+        # ignore file fields
+        next if field.type == :file
+        
+        key = field.key.to_sym
+        value = (field.value != nil || obj.class.db_schema[key].allow_null) ?
+          field.value : (obj.class.db_schema[key][:default] ||= field.format.default)
+        
+        if field.digest
+          value = Digest.const_get(field.digest.to_sym).hexdigest(value)
+        end
+        
+        obj[key] = value if field.save
+      end
+    end
+    
+    def set_objects_data(*args)
+      extract_objects_from_args(args).each do |obj|
+        next unless obj
+        set_object_data(obj)
+      end
+    end
+    
+    # Saves form input data associated with specified objects, or
+    # all form objects if objects are not specified here.
+    def save(*args)
+      db.transaction do
+        extract_objects_from_args(args).each do |obj|
+          set_object_data(obj)
+          obj.save
+        end
+      end
+    end
+    
+    def require_values(*names)
+      names.each {|name| fields[name.to_s].require_value }
+    end
+    
+    def with(*args, &block)
+      if block_given?
+        attrs = args.to_attrs
+        old_with = @_with
+        @_with = (@_with || {}).merge(attrs)
+      
+        instance_eval(&block)
+        
+        @_with = old_with
+      end
+    end
+    
+    def object(obj = nil, options = {}, &block)
+      if block_given?
+        raise 'missing object arg' unless obj
+        
+        if obj.is_a?(Symbol)
+          parent = @_object
+          raise 'missing parent object for object symbol reference' unless parent
+          obj = parent.send(obj) #||
+            #parent.set_associated_object(parent.class.association_reflection(object).associated_class.new)
+        end
+        raise 'object parameter must reference a model object' unless obj.is_a?(Kiss::Model)
+        
+        # if new, save early to give object a primary key, needed to save assoc children
+        @_objects_save_order << obj if obj.new?
+        prefix = options[:prefix]
+        
+        old_obj = @_object
+        old_prefix = @_field_name_prefix
+        
+        @_object = obj
+        @_field_name_prefix = (@_field_name_prefix + prefix.to_s + '.') if prefix
+        instance_eval(&block)
+        @_object = old_obj
+        @_field_name_prefix = old_prefix
+        
+        # save again to pick up any assoc ids from children
+        @_objects_save_order << obj
+        obj
+      elsif obj
+        @_object = obj
+      else
+        @_object
+      end
+    end
+    
+    # Returns true if form has errors.
+    def has_errors?
+      (@_errors.size > 0 || @_has_field_errors)
+    end
+    
     # Returns true if user submitted form with non-cancel submit button
     # (non-nil submit param, not equal to cancel submit button value).
     def accepted
-      raise 'form missing submit field' unless @submit
-      return params[@submit.name] != @submit.cancel
+      raise 'form missing submit field' unless @_submit
+      return params[@_submit.name] != @_submit.cancel
     end
     
     # Renders error HTML block for top of form, and returns as string.
     def errors_html
-      return nil unless has_errors
+      return nil unless has_errors?
       
-      @errors << "Please correct the errors highlighted below." if @has_field_errors
+      @_errors << "Please correct the #{@_errors.empty? ? '' : 'other '}errors highlighted below." if @_has_field_errors
       
-      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
       
-      @errors.pop if @has_field_errors
+      @_errors.pop if @_has_field_errors
       
-      plural = @errors.size > 1 || @has_field_errors ? 's' : nil
-      %Q(<div class="kiss_error">#{content}</div><br clear="all" />)
+      plural = @_errors.size > 1 || @_has_field_errors ? 's' : nil
+      %Q(<table class="kiss_error"><tr><td>#{content}</td></tr></table>)
     end
     
     # Renders current action using form's HTML as action render content.
     def render(options = {})
-      @request.render options.merge(:content => html)
+      @_delegate.render options.merge(:content => html)
+    end
+    
+    def form_name_hidden_tag_html
+      %Q(<input type=hidden name="form" value="#{@_name}">)
     end
     
     # Renders beginning of form (form open tag and form/field/error styles).
     def html_open
-      @error_class ||= 'kiss_form_error_message'
-      @field_error_class ||= @error_class
+      @_error_class ||= 'kiss_form_error_message'
+      @_field_error_class ||= @_error_class
       
       # form tag
-      form_attrs = ['method','enctype','class','style'].map do |attr|
+      form_attrs = ['id', 'method', 'enctype', 'class', 'style'].map do |attr|
+        next if (value = send attr).blank?
         "#{attr}=\"#{send attr}\""
-      end.join(' ')
-      form_tag = %Q(<form action="#{@action}" #{form_attrs}><input type=hidden name="form" value="#{@name}">)
+      end
+      if @_html
+        @_html.each_pair do |k, v|
+          form_attrs.push("#{k}=\"#{v}\"")
+        end
+      end
+      form_tag = %Q(<form action="#{@_action}" #{form_attrs.join(' ')}>#{form_name_hidden_tag_html})
       
       # style tag
       styles = []
@@ -275,15 +475,16 @@ table.kiss_form {
   vertical-align: middle;
 }
 .kiss_form .kiss_error {
+  margin-bottom: 4px;
+}
+.kiss_form .kiss_error td {
   background-color: #ff8;
   padding: 2px 4px;
   line-height: 135%;
-  float: left;
   color: #900;
   border: 1px solid #ea4;
-  margin-bottom: 4px;
 }
-.kiss_form .kiss_error ul {
+.kiss_form .kiss_error td ul {
   padding-left: 16px;
   margin: 0;
 }
@@ -312,11 +513,34 @@ table.kiss_form {
 .kiss_form tr.kiss_submit td.kiss_submit {
   padding: 6px 3px;
 }
-.kiss_form input[type="text"],.kiss_form input[type=password],.kiss_form textarea {
+.kiss_form input[type="text"],
+.kiss_form input[type=password],
+.kiss_form textarea {
   width: 250px;
   margin-left: 0;
   margin-right: 0;
 }
+.kiss_form table.kiss_field_columns {
+  border-spacing: 0;
+  border-collapse: collapse;
+  width: 100%;
+}
+.kiss_form table.kiss_field_columns td {
+  padding: 0 16px 2px 0;
+  vertical-align: top;
+}
+.kiss_form .kiss_checkbox .kiss_label {
+  vertical-align: top;
+  padding-top: 3px;
+}
+.kiss_form .kiss_radio .kiss_label {
+  vertical-align: top;
+  padding-top: 4px;
+}
+.kiss_form .kiss_textarea .kiss_label {
+  vertical-align: top;
+  padding-top: 3px;
+}
 EOT
       )
       styles.push( <<-EOT
@@ -349,39 +573,35 @@ tr.kiss_form_error_row .kiss_form_error_message {
   top: -2px;
   margin-bottom: 0;
 }
-.kiss_form table.kiss_field_columns {
-  border-spacing: 0;
-  border-collapse: collapse;
-}
-.kiss_form table.kiss_field_columns td {
-  padding: 0 0 2px 0;
-}
 EOT
-      ) if @error_class == 'kiss_form_error_message'
+      ) if @_error_class == 'kiss_form_error_message'
       style_tag = styles.size == 0 ? '' : "<style>" + styles.join('') + "</style>"
       
       # combine
-      return %Q(#{form_tag}#{style_tag}<div class="kiss_form">#{errors_html})
+      return %Q(#{@_prepend_html}#{form_tag}#{style_tag}<div class="kiss_form">#{errors_html})
     end
     
     # Renders end of form (form close tag).
     def html_close
-      '</div></form>'
+      "</div></form>#{@_append_html}"
     end
     
     # Renders form fields HTML.
-    def fields_html
-      @fields.map do |field|
-        field == :section_break ? begin
-          table_html_close + table_html_open
-        end : field_html(field)
+    def components_html
+      @_components.map do |component|
+        component_html(component)
       end.join
     end
+    alias_method :fields_html, :components_html
     
     # Renders open of form table.
     def table_html_open
-      %Q(<table class="kiss_form" border=0 cellspacing=0>) +
-        (@has_required_fields && @mark_required ? %Q( <tr><td></td><td class="kiss_help">Required fields marked by <span class="kiss_required">*</span></td></tr> ) : '')
+      %Q(<table class="kiss_form" border=0 cellspacing=0>)
+    end
+    
+    def required_legend_html
+      (@_has_required_fields && @_mark_required) ?
+        %Q( <tr><td></td><td class="kiss_help">Required fields marked by <span class="kiss_required">*</span></td></tr> ) : ''
     end
     
     # Renders close of form table.
@@ -391,7 +611,7 @@ EOT
     
     # Renders form submit buttons.
     def submit_html
-      @submit ? field_html(@submit) : ''
+      @_submit ? field_html(@_submit) : ''
     end
     
     # Renders complete form HTML.
@@ -399,7 +619,8 @@ EOT
       return [
         html_open,
         table_html_open,
-        fields_html,
+        required_legend_html,
+        components_html,
         submit_html,
         table_html_close,
         html_close
@@ -407,18 +628,21 @@ EOT
     end
     
     # Renders HTML for specified form field.
-    def field_html(field)
+    def component_html(field)
+      field = fields[field.to_s] if (field.is_a?(Symbol) || field.is_a?(String))
+      return field.element_html if field.type == :hidden
+      
       type = field.type
       prompt = field.prompt
       label = field.label
       errors = field.errors_html
-      required = field.required ? %Q(<span class="kiss_required">#{@mark_required}</span> ) : ''
+      required = field.required ? %Q(<span class="kiss_required">#{@_mark_required}</span> ) : ''
       
       ([
     	  prompt ? %Q(<tr class="kiss_prompt"><td class="kiss_label">#{required}</td><td>#{prompt.to_s}</td></tr>) : '',
     	  
         %Q(<tr class="kiss_#{type}"><td class="kiss_label#{errors ? ' error' : ''}">),
-        !prompt ? (required + (label ? label.to_s + ':' : '' )) : '',
+        !prompt ? (required + (label.blank? ? '' : label.to_s + ':' )) : '',
     	  %Q(</td><td class="kiss_#{type}">),
     		field.element_html, "</td></tr>"
     	] + (errors ? [
@@ -427,5 +651,6 @@ EOT
     	  '</td></tr>'
     	] : [])).join
     end
+    alias_method :field_html, :component_html
   end
 end