forme 0.9.2 → 0.10.0

data/Rakefile

@@ -25,7 +25,6 @@ end
 RDOC_DEFAULT_OPTS = ["--line-numbers", "--inline-source", '--title', 'Forme']
 
 begin
-  gem 'rdoc', '= 3.12.2'
   gem 'hanna-nouveau'
   RDOC_DEFAULT_OPTS.concat(['-f', 'hanna'])
 rescue Gem::LoadError
@@ -74,9 +73,11 @@ begin
 
   spec_with_cov = lambda do |name, files, d|
     spec.call(name, files, d)
-    t = spec.call("#{name}_cov", files, "#{d} with coverage")
-    t.rcov = true
-    t.rcov_opts = File.read("spec/rcov.opts").split("\n") if File.file?("spec/rcov.opts")
+    desc "#{d} with coverage"
+    task "#{name}_cov" do
+      ENV['COVERAGE'] = '1'
+      Rake::Task[name].invoke
+    end
   end
   
   task :default => [:spec]

data/lib/forme.rb

@@ -2,82 +2,28 @@ require 'date'
 require 'bigdecimal'
 require 'forme/version'
 
-# Forme is designed to make creating HTML forms easier.  Flexibility and
-# simplicity are primary objectives.  The basic usage involves creating
-# a <tt>Forme::Form</tt> instance, and calling +input+ and +tag+ methods
-# to return html strings for widgets, but it could also be used for
-# serializing to other formats, or even as a DSL for a GUI application.
-#
-# In order to be flexible, Forme stores tags in abstract form until
-# output is requested.  There are two separate abstract <i>forms</i> that Forme
-# uses.  One is <tt>Forme::Input</tt>, and the other is <tt>Forme::Tag</tt>.
-# <tt>Forme::Input</tt> is a high level abstract form, while <tt>Forme::Tag</tt>
-# is a low level abstract form.
-#
-# The difference between <tt>Forme::Input</tt> and <tt>Forme::Tag</tt> 
-# is that <tt>Forme::Tag</tt> directly represents the underlying html
-# tag, containing a type, optional attributes, and children, while the
-# <tt>Forme::Input</tt> is more abstract and attempts to be user friendly.
-# For example, these both compile by default to the same select tag:
-# 
-#   f.input(:select, :options=>[['foo', 1]])
-#   # or
-#   f.tag(:select, {}, [f.tag(:option, {:value=>1}, ['foo'])])
-#
-# The processing of high level <tt>Forme::Input</tt>s into raw html
-# data is broken down to the following steps (called transformers):
-#
-# 1. +Formatter+: converts a <tt>Forme::Input</tt> instance into a
-#    <tt>Forme::Tag</tt> instance (or array of them).
-# 2. +ErrorHandler+: If the <tt>Forme::Input</tt> instance has a error,
-#    takes the formatted tag and marks it as having the error.
-# 2. +Labeler+: If the <tt>Forme::Input</tt> instance has a label,
-#    takes the formatted output and labels it.
-# 3. +Wrapper+: Takes the output of the labeler (or formatter if
-#    no label), and wraps it in another tag (or just returns it
-#    directly).
-# 4. +Serializer+: converts a <tt>Forme::Tag</tt> instance into a
-#    string.
-#
-# Technically, only the +Serializer+ is necessary.  The +input+
-# and +tag+ methods return +Input+ and +Tag+ objects.  These objects
-# both have +to_s+ defined to call the appropriate +Serializer+ with
-# themselves.  The +Serializer+ calls the appropriate +Formatter+ if
-# it encounters an +Input+ instance, and attempts to serialize the
-# output of that (which is usually a +Tag+ instance).  It is up to
-# the +Formatter+ to call the +Labeler+ and/or +ErrorHandler+ (if
-# necessary) and the +Wrapper+.
-# 
-# There is also an +InputsWrapper+ transformer, that is called by
-# <tt>Forme::Form#inputs</tt>.  It's used to wrap up a group of
-# related options (in a fieldset by default).
-#
-# The <tt>Forme::Form</tt> object takes the 6 transformers as options (:formatter,
-# :labeler, :error_handler, :wrapper, :inputs_wrapper, and :serializer), all of which
-# should be objects responding to +call+ (so you can use +Proc+s) or be symbols
-# registered with the library using <tt>Forme.register_transformer</tt>:
-#
-#   Forme.register_transformer(:wrapper, :p){|t| t.tag(:p, {}, t)}
-#
-# Most of the transformers can be overridden on a per instance basis by
-# passing the appopriate option to +input+ or +inputs+:
-#
-#   f.input(:name, :wrapper=>:p)
 module Forme
   # Exception class for exceptions raised by Forme.
   class Error < StandardError
   end
-  
+
+  @default_add_blank_prompt = nil
   @default_config = :default
   class << self
     # Set the default configuration to use if none is explicitly
     # specified (default: :default).
     attr_accessor :default_config
+
+    # The default prompt to use for the :add_blank option (default: nil).
+    attr_accessor :default_add_blank_prompt
   end
 
   # Array of all supported transformer types.
   TRANSFORMER_TYPES = [:formatter, :serializer, :wrapper, :error_handler, :labeler, :inputs_wrapper]
 
+  # Transformer symbols shared by wrapper and inputs_wrapper
+  SHARED_WRAPPERS = [:tr, :table, :ol, :fieldset_ol]
+
   # Hash storing all configurations.  Configurations are groups of related transformers,
   # so that you can specify a single :config option when creating a +Form+ and have
   # all of the transformers set from that.
@@ -131,66 +77,77 @@ module Forme
     classes.compact.join(' ')
   end
 
+  # If there is a related transformer, call it with the given +args+ and +block+.
+  # Otherwise, attempt to return the initial input without modifying it.
+  def self.transform(type, trans_name, default_opts, *args, &block)
+    if trans = transformer(type, trans_name, default_opts)
+      trans.call(*args, &block)
+    else
+      case type
+      when :inputs_wrapper
+        yield
+      when :labeler, :error_handler, :wrapper
+        args.first
+      else
+        raise Error, "No matching #{type}: #{trans_name.inspect}"
+      end
+    end
+  end
+
+  # Get the related transformer for the given transformer type.  Output depends on the type
+  # of +trans+:
+  # +Symbol+ :: Assume a request for a registered transformer, so look it up in the +TRANSFORRMERS+ hash.
+  # +Hash+ :: If +type+ is also a key in +trans+, return the related value from +trans+, unless the related
+  #           value is +nil+, in which case, return +nil+.  If +type+ is not a key in +trans+, use the
+  #           default transformer for the receiver.
+  # +nil+ :: Assume the default transformer for this receiver.
+  # otherwise :: return +trans+ directly if it responds to +call+, and raise an +Error+ if not.
+  def self.transformer(type, trans, default_opts)
+    case trans
+    when Symbol
+      TRANSFORMERS[type][trans] || raise(Error, "invalid #{type}: #{trans.inspect} (valid #{type}s: #{TRANSFORMERS[type].keys.map{|k| k.inspect}.join(', ')})")
+    when Hash
+      if trans.has_key?(type)
+        if v = trans[type]
+          transformer(type, v, default_opts)
+        end
+      else
+        transformer(type, nil, default_opts)
+      end
+    when nil
+      transformer(type, default_opts[type], nil) if default_opts
+    else
+      if trans.respond_to?(:call)
+        trans
+      else
+        raise Error, "#{type} #{trans.inspect} must respond to #call"
+      end
+    end
+  end
+
   # The +Form+ class is the main entry point to the library.  
   # Using the +form+, +input+, +tag+, and +inputs+ methods, one can easily build 
   # an abstract syntax tree of +Tag+ and +Input+ instances, which can be serialized
   # to a string using +to_s+.
   class Form
-    # The object related to the receiver, if any.  If the +Form+ has an associated
-    # obj, then calls to +input+ are assumed to be accessing fields of the object
-    # instead to directly representing input types.
-    attr_reader :obj
-
-    # A hash of options for the receiver. Currently, the following are recognized by
-    # default:
-    # :obj :: Sets the +obj+ attribute
-    # :error_handler :: Sets the +error_handler+ for the form
-    # :formatter :: Sets the +formatter+ for the form
-    # :hidden_tags :: Sets the hidden tags to automatically add to this form.
-    # :input_defaults :: Sets the default options for each input type
-    # :inputs_wrapper :: Sets the +inputs_wrapper+ for the form
-    # :labeler :: Sets the +labeler+ for the form
-    # :wrapper :: Sets the +wrapper+ for the form
-    # :serializer :: Sets the +serializer+ for the form
+    # A hash of options for the form.
     attr_reader :opts
 
-    # The +formatter+ determines how the +Input+s created are transformed into
-    # +Tag+ objects. Must respond to +call+ or be a registered symbol.
-    attr_reader :formatter
-
-    # The +error_handler+ determines how to to mark tags as containing errors.
-    # Must respond to +call+ or be a registered symbol.
-    attr_reader :error_handler
-
-    # The +labeler+ determines how to label tags.  Must respond to +call+ or be
-    # a registered symbol.
-    attr_reader :labeler
-
-    # The +wrapper+ determines how (potentially labeled) tags are wrapped.  Must
-    # respond to +call+ or be a registered symbol.
-    attr_reader :wrapper
-
     # Set the default options for inputs by type.  This should be a hash with
-    # input type string keys and values that are hashes of input options.
+    # input type keys and values that are hashes of input options.
     attr_reader :input_defaults
 
-    # The +inputs_wrapper+ determines how calls to +inputs+ are wrapped.  Must
-    # respond to +call+ or be a registered symbol.
-    attr_reader :inputs_wrapper
+    # The hidden tags to automatically add to the form.
+    attr_reader :hidden_tags
+
+    # The namespaces if any for the receiver's inputs.  This can be used to
+    # automatically setup namespaced class and id attributes.
+    attr_accessor :namespaces
 
     # The +serializer+ determines how +Tag+ objects are transformed into strings.
     # Must respond to +call+ or be a registered symbol.
     attr_reader :serializer
 
-    # The hidden tags to automatically add to the form.  If set, this should be an
-    # array, where elements are one of the following types:
-    # String, Array, Forme::Tag :: Added directly as a child of the form tag.
-    # Hash :: Adds a hidden tag for each entry, with keys as the name of the hidden
-    #         tag and values as the value of the hidden tag.
-    # Proc :: Will be called with the form tag object, and should return an instance
-    #         of one of the handled types (or nil to not add a tag).
-    attr_reader :hidden_tags
-
     # Create a +Form+ instance and yield it to the block,
     # injecting the opening form tag before yielding and
     # the closing form tag after yielding.
@@ -233,72 +190,31 @@ module Forme
     # Creates a +Form+ object. Arguments:
     # obj :: Sets the obj for the form.  If a hash, is merged with the +opts+ argument
     #        to set the opts.
-    # opts :: A hash of options for the form, see +opts+ attribute for details on
-    #         available options.
+    # opts :: A hash of options for the form
     def initialize(obj=nil, opts={})
-      if obj.is_a?(Hash)
-        @opts = obj.merge(opts)
-        @obj = @opts.delete(:obj)
-      else
-        @obj = obj
-        @opts = opts
-      end
-      if @obj && @obj.respond_to?(:forme_config)
-        @obj.forme_config(self)
-      end
-      config = CONFIGURATIONS[@opts[:config]||Forme.default_config]
-      TRANSFORMER_TYPES.each{|k| instance_variable_set(:"@#{k}", transformer(k, @opts.fetch(k, config[k])))}
-      @input_defaults = @opts[:input_defaults] || {}
-      @hidden_tags = @opts[:hidden_tags]
-      @nesting = []
-    end
+      @opts = opts.merge(obj.is_a?(Hash) ? obj : {:obj=>obj})
+      @opts[:namespace] = Array(@opts[:namespace])
 
-    # If there is a related transformer, call it with the given +args+ and +block+.
-    # Otherwise, attempt to return the initial input without modifying it.
-    def transform(type, trans_name, *args, &block)
-      if trans = transformer(type, trans_name)
-        trans.call(*args, &block)
-      else
-        case type
-        when :inputs_wrapper
-          yield
-        when :labeler, :error_handler, :wrapper
-          args.first
-        else
-          raise Error, "No matching #{type}: #{trans_name.inspect}"
-        end
+      if obj && obj.respond_to?(:forme_config)
+        obj.forme_config(self)
       end
-    end
 
-    # Get the related transformer for the given transformer type.  Output depends on the type
-    # of +trans+:
-    # +Symbol+ :: Assume a request for a registered transformer, so look it up in the +TRANSFORRMERS+ hash.
-    # +Hash+ :: If +type+ is also a key in +trans+, return the related value from +trans+, unless the related
-    #           value is +nil+, in which case, return +nil+.  If +type+ is not a key in +trans+, use the
-    #           default transformer for the receiver.
-    # +nil+ :: Assume the default transformer for this receiver.
-    # otherwise :: return +trans+ directly if it responds to +call+, and raise an +Error+ if not.
-    def transformer(type, trans)
-      case trans
-      when Symbol
-        TRANSFORMERS[type][trans] || raise(Error, "invalid #{type}: #{trans.inspect} (valid #{type}s: #{TRANSFORMERS[type].keys.map{|k| k.inspect}.join(', ')})")
-      when Hash
-        if trans.has_key?(type)
-          if v = trans[type]
-            transformer(type, v)
-          end
-        else
-          transformer(type, nil)
-        end
-      when nil
-        send(type)
-      else
-        if trans.respond_to?(:call)
-          trans
-        else
-          raise Error, "#{type} #{trans.inspect} must respond to #call"
+      config = CONFIGURATIONS[@opts[:config]||Forme.default_config]
+      copy_inputs_wrapper_from_wrapper(@opts)
+
+      TRANSFORMER_TYPES.each do |t|
+        case @opts[t]
+        when Symbol
+          @opts[t] = Forme.transformer(t, @opts[t], @opts)
+        when nil
+          @opts[t] = Forme.transformer(t, config, @opts)
         end
       end
+
+      @serializer = @opts[:serializer]
+      @input_defaults = @opts[:input_defaults] || {}
+      @hidden_tags = @opts[:hidden_tags]
+      @nesting = []
     end
 
     # Create a form tag with the given attributes.
@@ -306,11 +222,6 @@ module Forme
       tag(:form, attr, method(:hidden_form_tags), &block)
     end
 
-    # Formats the +input+ using the +formatter+.
-    def format(input)
-      transform(:formatter, input.opts, input)
-    end
-
     # Empty method designed to ease integration with other libraries where
     # Forme is used in template code and some output implicitly
     # created by Forme needs to be injected into the template output.
@@ -342,15 +253,19 @@ module Forme
           obj.forme_input(self, field, opts.dup)
         else
           opts = opts.dup
-          opts[:name] = field unless opts.has_key?(:name)
-          opts[:id] = field unless opts.has_key?(:id)
-          opts[:value] = obj.send(field) unless opts.has_key?(:value)
+          opts[:key] = field unless opts.has_key?(:key)
+          unless opts.has_key?(:value)
+            opts[:value] = if obj.is_a?(Hash)
+              obj[field]
+            else
+              obj.send(field)
+            end
+          end
           _input(:text, opts)
         end
       else
         _input(field, opts)
       end
-      use_serializer(input) if input.is_a?(Array)
       self << input
       input
     end
@@ -362,7 +277,7 @@ module Forme
     end
 
     # Creates a tag using the +inputs_wrapper+ (a fieldset by default), calls
-    # input on each element of +inputs+, and yields to if given a block.
+    # input on each element of +inputs+, and yields if given a block.
     # You can use array arguments if you want inputs to be created with specific
     # options:
     #
@@ -372,22 +287,47 @@ module Forme
     # The given +opts+ are passed to the +inputs_wrapper+, and the default
     # +inputs_wrapper+ supports a <tt>:legend</tt> option that is used to
     # set the legend for the fieldset.
-    def inputs(*a, &block)
-      _inputs(*a, &block)
+    #
+    # +opts+ can also include transformer options itself (e.g. :wrapper), which
+    # override the form's current transformer options for the duration of the block.
+    # The exception is the :inputs_wrapper transformer option, which affects the
+    # wrapper to use for this inputs call.  You can use the :nested_inputs_wrapper
+    # option to set the default :inputs_wrapper option for the duration of the block.
+    #
+    # This can also be called with a single hash argument to just use an options hash:
+    #
+    #   inputs(:legend=>'Foo'){...}
+    #
+    # or even without any arguments:
+    #
+    #   inputs{...}
+    def inputs(inputs=[], opts={}, &block)
+      _inputs(inputs, opts, &block)
     end
     
     # Internals of #inputs, should be used internally by the library, where #inputs
-    # is designed for external use.
-    def _inputs(inputs=[], opts={})
+    # is designed for external use. 
+    def _inputs(inputs=[], opts={}) # :nodoc:
       if inputs.is_a?(Hash)
         opts = inputs.merge(opts)
         inputs = []
       end
-      transform(:inputs_wrapper, opts, self, opts) do
-        inputs.each do |i|
-          emit(input(*i))
+
+      form_opts = {}
+      form_opts[:inputs_wrapper] = opts[:nested_inputs_wrapper] if opts[:nested_inputs_wrapper]
+      TRANSFORMER_TYPES.each do |t|
+        if opts.has_key?(t) && t != :inputs_wrapper
+          form_opts[t] = opts[t]
+        end
+      end
+
+      Forme.transform(:inputs_wrapper, opts, @opts, self, opts) do
+        with_opts(form_opts) do
+          inputs.each do |i|
+            emit(input(*i))
+          end
+          yield if block_given?
         end
-        yield if block_given?
       end
     end
 
@@ -409,6 +349,18 @@ module Forme
       tag = Tag.new(self, *a, &block)
     end
 
+    # The object associated with this form, if any. If the +Form+ has an associated
+    # obj, then calls to +input+ are assumed to be accessing fields of the object
+    # instead to directly representing input types.
+    def obj
+      @opts[:obj]
+    end
+
+    # The current namespaces for the form, if any.
+    def namespaces
+      @opts[:namespace]
+    end
+
     # Creates a +Tag+ associated to the receiver with the given arguments.
     # Add the tag to the the list of children for the currently open tag.
     # If a block is given, make this tag the currently open tag while inside
@@ -420,7 +372,8 @@ module Forme
       tag
     end
 
-    def tag_(*a, &block)
+    # Aliased for tag.  Workaround for issue with rails plugin.
+    def tag_(*a, &block) # :nodoc:
       tag(*a, &block)
     end
 
@@ -440,13 +393,46 @@ module Forme
       end
     end
 
-    # Serializes the +tag+ using the +serializer+.
-    def serialize(tag)
-      serializer.call(tag)
+    # Calls the block for each object in objs, using with_obj with the given namespace
+    # and an index namespace (starting at 0).
+    def each_obj(objs, namespace=nil)
+      objs.each_with_index do |obj, i|
+        with_obj(obj, Array(namespace) + [i]) do
+          yield obj, i
+        end
+      end
+    end
+
+    # Temporarily override the given object and namespace for the form.  Any given
+    # namespaces are appended to the form's current namespace.
+    def with_obj(obj, namespace=nil)
+      with_opts(:obj=>obj, :namespace=>@opts[:namespace]+Array(namespace)) do
+        yield obj
+      end
+    end
+
+    # Temporarily override the opts for the form for the duration of the block.
+    # This merges the given opts with the form's current opts, restoring
+    # the previous opts before returning.
+    def with_opts(opts)
+      orig_opts = @opts
+      @opts = orig_opts.merge(opts)
+      copy_inputs_wrapper_from_wrapper(opts, @opts)
+      yield
+    ensure
+      @opts = orig_opts if orig_opts
     end
 
     private
 
+    # Copy the :wrapper option to :inputs_wrapper in output_opts if only :wrapper
+    # is present in input_opts and the :wrapper option value is a shared wrapper.
+    def copy_inputs_wrapper_from_wrapper(input_opts, output_opts=input_opts)
+      if input_opts[:wrapper] && !input_opts[:inputs_wrapper] && SHARED_WRAPPERS.include?(input_opts[:wrapper])
+        output_opts[:inputs_wrapper] = output_opts[:wrapper]
+      end
+    end
+
     # Return array of hidden tags to use for this form,
     # or nil if the form does not have hidden tags added automatically.
     def hidden_form_tags(form_tag)
@@ -476,15 +462,6 @@ module Forme
       end
     end
 
-    # Extend +obj+ with +Serialized+ and associate it with the receiver, such
-    # that calling +to_s+ on the object will use the receiver's serializer
-    # to generate the resulting string.
-    def use_serializer(obj)
-      obj.extend(Serialized)
-      obj._form = self
-      obj
-    end
-
     # Make the given tag the currently open tag, and yield.  After the
     # block returns, make the previously open tag the currently open
     # tag.
@@ -505,35 +482,18 @@ module Forme
     # The type of input, should be a symbol (e.g. :submit, :text, :select).
     attr_reader :type
 
-    # The options hash for the receiver.  Here are some of the supported options
-    # used by the built-in formatter transformers:
-    #
-    # :error :: Set an error message, invoking the error_handler
-    # :label :: Set a label, invoking the labeler
-    # :wrapper :: Set a custom wrapper, overriding the form's default
-    # :labeler :: Set a custom labeler, overriding the form's default
-    # :error_handler :: Set a custom error_handler, overriding the form's default
-    # :attr :: The attributes hash to use for the given tag, takes precedence over
-    #          other options that set attributes.
-    # :data :: A hash of data-* attributes for the resulting tag.  Keys in this hash
-    #          will have attributes created with data- prepended to the attribute name.
-    # :name :: The name attribute to use
-    # :id :: The id attribute to use
-    # :placeholder :: The placeholder attribute to use
-    # :value :: The value attribute to use for input tags, the content of the textarea
-    #           for textarea tags, or the selected option(s) for select tags.
-    # :class :: A class to use.  Unlike other options, this is combined with the
-    #           classes set in the :attr hash.
-    # :disabled :: Set the disabled attribute if true
-    # :required :: Set the required attribute if true
-    #
-    # For other supported options, see the private methods in +Formatter+.
+    # The options hash for the Input.
     attr_reader :opts
 
+    # The options hash in use by the form at the time of the Input's instantiation.
+    attr_reader :form_opts
+
     # Set the +form+, +type+, and +opts+.
     def initialize(form, type, opts={})
       @form, @type = form, type
-      @opts = (form.input_defaults[type.to_s] || {}).merge(opts)
+      defaults = form.input_defaults
+      @opts = (defaults.fetch(type){defaults[type.to_s]} || {}).merge(opts)
+      @form_opts = form.opts
     end
 
     # Replace the +opts+ by merging the given +hash+ into +opts+,
@@ -550,13 +510,13 @@ module Forme
 
     # Return a string containing the serialized content of the receiver.
     def to_s
-      form.serialize(self)
+      Forme.transform(:serializer, @opts, @form_opts, self)
     end
 
     # Transform the receiver into a lower level +Tag+ form (or an array
     # of them).
     def format
-      form.format(self)
+      Forme.transform(:formatter, @opts, @form_opts, self)
     end
   end
 
@@ -599,7 +559,7 @@ module Forme
 
     # Return a string containing the serialized content of the receiver.
     def to_s
-      form.serialize(self)
+      Forme.transform(:serializer, @opts, @form.opts, self)
     end
 
     private
@@ -619,19 +579,6 @@ module Forme
     end
   end
 
-  # Module that can extend objects associating them with a specific
-  # +Form+ instance.  Calling +to_s+ on the object will then use the
-  # form's serializer to return a string.
-  module Serialized
-    # The +Form+ instance related to the receiver.
-    attr_accessor :_form
-
-    # Return a string containing the serialized content of the receiver.
-    def to_s
-      _form.serialize(self)
-    end
-  end
-
   # Empty module for marking objects as "raw", where they will no longer
   # html escaped by the default serializer.
   module Raw
@@ -654,6 +601,11 @@ module Forme
     # the :attr option version takes precedence.
     ATTRIBUTE_OPTIONS = [:name, :id, :placeholder, :value, :style]
 
+    # Options copied from the options hash into the attributes hash,
+    # where a true value in the options hash sets the attribute
+    # value to the same name as the key.
+    ATTRIBUTE_BOOLEAN_OPTIONS = [:autofocus, :required, :disabled]
+
     # Create a new instance and call it
     def self.call(input)
       new.call(input)
@@ -716,10 +668,7 @@ module Forme
     # same name that comes before this checkbox.  That way, if the checkbox
     # is checked, the web app will generally see the value of the checkbox, and
     # if it is not checked, the web app will generally see the value of the hidden
-    # input tag.  Recognizes the following options:
-    # :checked :: checkbox is set to checked if so.
-    # :hidden_value :: sets the value of the hidden input tag.
-    # :no_hidden :: don't create a hidden input tag
+    # input tag.
     def format_checkbox
       @attr[:type] = :checkbox
       @attr[:checked] = :checked if @opts[:checked]
@@ -791,69 +740,76 @@ module Forme
     end
 
     # Takes a select input and turns it into a select tag with (possibly) option
-    # children tags.  Respects the following options:
-    # :options :: an array of options.  Processes each entry.  If that entry is
-    #             an array, takes the first entry in the hash as the text child
-    #             of the option, and the last entry as the value of the option.
-    #             if not set, ignores the remaining options.
-    # :add_blank :: Add a blank option if true.  If the value is a string,
-    #               use it as the text content of the blank option.  The value of
-    #               the blank option is always the empty string.
-    # :text_method :: If set, each entry in the array has this option called on
-    #                 it to get the text of the object.
-    # :value_method :: If set (and :text_method is set), each entry in the array
-    #                  has this method called on it to get the value of the option.
-    # :selected :: The value that should be selected.  Any options that are equal to
-    #              this value (or included in this value if a multiple select box),
-    #              are set to selected.
-    # :multiple :: Creates a multiple select box.
-    # :value :: Same as :selected, but has lower priority.
+    # children tags.
     def format_select
-      if os = @opts[:options]
-        vm = @opts[:value_method]
-        tm = @opts[:text_method]
-        sel = @opts[:selected] || @attr.delete(:value)
-        if @opts[:multiple]
-          @attr[:multiple] = :multiple
-          sel = Array(sel)
-          cmp = lambda{|v| sel.include?(v)}
-        else
-          cmp = lambda{|v| v == sel}
-        end
-        os = os.map do |x|
-          attr = {}
-          if tm
-            text = x.send(tm)
-            if vm
-              val = x.send(vm)
-              attr[:value] = val
-              attr[:selected] = :selected if cmp.call(val)
-            else
-              attr[:selected] = :selected if cmp.call(text)
-            end
-            form._tag(:option, attr, [text])
-          elsif x.is_a?(Array)
-            val = x.last
-            if val.is_a?(Hash)
-              attr.merge!(val)
-              val = attr[:value]
-            else
-              attr[:value] = val
-            end
-            attr[:selected] = :selected if attr.has_key?(:value) && cmp.call(val)
-            tag(:option, attr, [x.first])
-          else
-            attr[:selected] = :selected if cmp.call(x)
-            tag(:option, attr, [x])
+      if os = process_select_options(@opts[:options])
+        @attr[:multiple] = :multiple if @opts[:multiple]
+
+        os = os.map do |label, value, sel, attrs|
+          if value || sel
+            attrs = attrs.dup
+            attrs[:value] = value if value
+            attrs[:selected] = :selected if sel
           end
-        end
-        if prompt = @opts[:add_blank]
-          os.unshift(tag(:option, {:value=>''}, prompt.is_a?(String) ? [prompt] : []))
+          tag(:option, attrs, [label])
         end
       end
       tag(:select, @attr, os)
     end
 
+    def format_checkboxset
+      @opts[:multiple] = true unless @opts.has_key?(:multiple)
+      _format_set(:checkbox, :no_hidden=>true, :multiple=>true)
+    end
+
+    def format_radioset
+      _format_set(:radio)
+    end
+
+    def _format_set(type, tag_attrs={})
+      raise Error, "can't have radioset with no options" unless os = @opts[:options]
+      key = @opts[:key]
+      name = @opts[:name]
+      id = @opts[:id]
+      if @opts[:error]
+        @opts[:set_error] = @opts.delete(:error)
+      end
+      if @opts[:label]
+        @opts[:set_label] = @opts.delete(:label)
+      end
+      tag_wrapper = @opts.delete(:tag_wrapper) || :default
+      wrapper = Forme.transformer(:wrapper, @opts, @input.form_opts)
+
+      tags = process_select_options(os).map do |label, value, sel, attrs|
+        value ||= label
+        r_opts = attrs.merge(tag_attrs).merge(:label=>label||value, :label_attr=>{:class=>:option}, :wrapper=>tag_wrapper)
+        r_opts[:value] ||= value if value
+        r_opts[:checked] ||= :checked if sel
+
+        if name
+          r_opts[:name] ||= name
+        end
+        if id
+          r_opts[:id] ||= "#{id}_#{value}"
+        end
+        if key
+          r_opts[:key] ||= key
+          r_opts[:key_id] ||= value
+        end
+
+        form._input(type, r_opts)
+      end
+
+      if (last_input = tags.last) && last_input.is_a?(Input)
+        last_input.opts[:error] = @opts[:set_error]
+      else
+        tags << form._tag(:span, {:class=>'error_message'}, [@opts[:set_error]])
+      end
+      tags.unshift(form._tag(:span, {:class=>:label}, @opts[:set_label])) if @opts[:set_label]
+      wrapper.call(tags, form._input(type, opts)) if wrapper
+      tags
+    end
+
     # Formats a textarea.  Respects the following options:
     # :value :: Sets value as the child of the textarea.
     def format_textarea
@@ -865,19 +821,31 @@ module Forme
       end
     end
 
-    def copy_options_to_attributes(attributes)
-      attributes.each do |k|
+    # Copy option values for given keys to the attributes unless the
+    # attributes already have a value for the key.
+    def copy_options_to_attributes(keys)
+      keys.each do |k|
         if @opts.has_key?(k) && !@attr.has_key?(k)
           @attr[k] = @opts[k]
         end
       end
     end
 
-    # Normalize the options used for all input types.  Handles:
-    # :required :: Sets the +required+ attribute on the resulting tag if true.
-    # :disabled :: Sets the +disabled+ attribute on the resulting tag if true.
+    # Set attribute values for given keys to be the same as the key
+    # unless the attributes already have a value for the key.
+    def copy_boolean_options_to_attributes(keys)
+      keys.each do |k|
+        if @opts[k] && !@attr.has_key?(k)
+          @attr[k] = k
+        end
+      end
+    end
+
+    # Normalize the options used for all input types.
     def normalize_options
       copy_options_to_attributes(ATTRIBUTE_OPTIONS)
+      copy_boolean_options_to_attributes(ATTRIBUTE_BOOLEAN_OPTIONS)
+      handle_key_option
 
       Forme.attr_classes(@attr, @opts[:class]) if @opts.has_key?(:class)
       Forme.attr_classes(@attr, 'error') if @opts[:error]
@@ -888,9 +856,110 @@ module Forme
           @attr[sym] = v unless @attr.has_key?(sym)
         end
       end
+    end
 
-      @attr[:required] = :required if @opts[:required] && !@attr.has_key?(:required)
-      @attr[:disabled] = :disabled if @opts[:disabled] && !@attr.has_key?(:disabled)
+    # Have the :key option possibly set the name, id, and/or value attributes if not already set.
+    def handle_key_option
+      if key = @opts[:key]
+        unless @attr[:name] || @attr['name']
+          @attr[:name] = namespaced_name(key, @opts[:array] || @opts[:multiple])
+          if !@attr.has_key?(:value) && !@attr.has_key?('value') && (values = @form.opts[:values])
+            set_value_from_namespaced_values(namespaces, values, key)
+          end
+        end
+        unless @attr[:id] || @attr['id']
+          id = namespaced_id(key)
+          if suffix = @opts[:key_id]
+            id << '_' << suffix.to_s
+          end
+          @attr[:id] = id
+        end
+      end
+    end
+
+    # Array of namespaces to use for the input
+    def namespaces
+      input.form_opts[:namespace]
+    end
+
+    # Return a unique id attribute for the +field+, based on the current namespaces.
+    def namespaced_id(field)
+      "#{namespaces.join('_')}#{'_' unless namespaces.empty?}#{field}"
+    end
+
+    # Return a unique name attribute for the +field+, based on the current namespaces.
+    # If +multiple+ is true, end the name with [] so that param parsing will treat
+    # the name as part of an array.
+    def namespaced_name(field, multiple=false)
+      if namespaces.empty?
+        if multiple
+          "#{field}[]"
+        else
+          field
+        end
+      else
+        root, *nsps = namespaces
+        "#{root}#{nsps.map{|n| "[#{n}]"}.join}[#{field}]#{'[]' if multiple}"
+      end
+    end
+
+    # Set the values option based on the (possibly nested) values
+    # hash given, array of namespaces, and key.
+    def set_value_from_namespaced_values(namespaces, values, key)
+      namespaces.each do |ns|
+        v = values[ns] || values[ns.to_s]
+        return unless v
+        values = v
+      end
+
+      @attr[:value] = values.fetch(key){values.fetch(key.to_s){return}}
+    end
+
+    # Returns an array of arrays, where each array entry contains the label, value,
+    # currently selected flag, and attributes for that tag.
+    def process_select_options(os)
+      if os
+        vm = @opts[:value_method]
+        tm = @opts[:text_method]
+        sel = @opts[:selected] || @attr.delete(:value)
+
+        if @opts[:multiple]
+          sel = Array(sel)
+          cmp = lambda{|v| sel.include?(v)}
+        else
+          cmp = lambda{|v| v == sel}
+        end
+
+        os = os.map do |x|
+          attr = {}
+          if tm
+            text = x.send(tm)
+            val = x.send(vm) if vm
+          elsif x.is_a?(Array)
+            text = x.first
+            val = x.last
+
+            if val.is_a?(Hash)
+              value = val[:value]
+              attr.merge!(val)
+              val = value
+            end
+          else
+            text = x
+          end
+
+          [text, val, val ? cmp.call(val) : cmp.call(text), attr]
+        end
+
+        if prompt = @opts[:add_blank]
+          unless prompt.is_a?(String)
+            prompt = Forme.default_add_blank_prompt
+          end
+          os.unshift([prompt, '', false, {}])
+        end
+
+        os
+      end
     end
 
     # Create a +Tag+ instance related to the receiver's +form+ with the given
@@ -901,17 +970,17 @@ module Forme
     
     # Wrap the tag with the form's +wrapper+.
     def wrap_tag(tag)
-      form.transform(:wrapper, @opts, tag, input)
+      Forme.transform(:wrapper, @opts, input.form_opts, tag, input)
     end
 
     # Wrap the tag with the form's +error_handler+.
     def wrap_tag_with_error(tag)
-      form.transform(:error_handler, @opts, tag, input)
+      Forme.transform(:error_handler, @opts, input.form_opts, tag, input)
     end
 
     # Wrap the tag with the form's +labeler+.
     def wrap_tag_with_label(tag)
-      form.transform(:labeler, @opts, tag, input)
+      Forme.transform(:labeler, @opts, input.form_opts, tag, input)
     end
   end
 
@@ -1038,14 +1107,24 @@ module Forme
     # :label_for option is used, the label created will not be
     # associated with an input.
     def call(tag, input)
+      unless id = input.opts[:id]
+        if key = input.opts[:key]
+          namespaces = input.form_opts[:namespace]
+          id = "#{namespaces.join('_')}#{'_' unless namespaces.empty?}#{key}"
+          if key_id = input.opts[:key_id]
+            id << "_#{key_id.to_s}"
+          end
+        end
+      end
       if [:radio, :checkbox].include?(input.type)
-        t = [tag, input.tag(:label, {:for=>input.opts.fetch(:label_for, input.opts[:id])}.merge(input.opts[:label_attr]||{}), [input.opts[:label]])]
-        p = :before
+        t = [tag, input.tag(:label, {:for=>input.opts.fetch(:label_for, id)}.merge(input.opts[:label_attr]||{}), [input.opts[:label]])]
+        pos = :before
       else
-        t = [input.tag(:label, {:for=>input.opts.fetch(:label_for, input.opts[:id])}.merge(input.opts[:label_attr]||{}), [input.opts[:label]]), tag]
-        p = :after
+        t = [input.tag(:label, {:for=>input.opts.fetch(:label_for, id)}.merge(input.opts[:label_attr]||{}), [input.opts[:label]]), tag]
+        pos = :after
       end
-      if input.opts[:label_position] == p
+
+      if input.opts[:label_position] == pos
         t.reverse
       else
         t
@@ -1054,7 +1133,7 @@ module Forme
   end
 
   Forme.register_transformer(:wrapper, :default){|tag, input| tag}
-  [:li, :p, :div, :span].each do |x|
+  [:li, :p, :div, :span, :td].each do |x|
     Forme.register_transformer(:wrapper, x){|tag, input| input.tag(x, input.opts[:wrapper_attr], Array(tag))}
   end
   Forme.register_transformer(:wrapper, :trtd) do |tag, input|
@@ -1071,15 +1150,18 @@ module Forme
     end
     input.tag(:tr, input.opts[:wrapper_attr], [input.tag(:td, {}, ltd), input.tag(:td, {}, rtd)])
   end
+  {:tr=>:td, :table=>:trtd, :ol=>:li, :fieldset_ol=>:li}.each do |k, v|
+    Forme.register_transformer(:wrapper, k, TRANSFORMERS[:wrapper][v])
+  end
 
-  # Default inputs_wrapper used by the library, uses a fieldset.
+  # Default inputs_wrapper used by the library, uses a <fieldset>.
   #
   # Registered as :default.
   class InputsWrapper
     Forme.register_transformer(:inputs_wrapper, :default, new)
 
-    # Wrap the inputs in a fieldset.  If the :legend
-    # option is given, add a +legend+ tag as the first
+    # Wrap the inputs in a <fieldset>.  If the :legend
+    # option is given, add a <legend> tag as the first
     # child of the fieldset.
     def call(form, opts)
       attr = opts[:attr] ? opts[:attr].dup : {}
@@ -1095,51 +1177,74 @@ module Forme
     end
   end
 
-  # Use a fieldset and an ol tag to wrap the inputs.
+  # Use a <fieldset> and an <ol> tag to wrap the inputs.
   #
   # Registered as :fieldset_ol.
   class InputsWrapper::FieldSetOL < InputsWrapper
     Forme.register_transformer(:inputs_wrapper, :fieldset_ol, new)
 
-    # Wrap the inputs in an ol tag
+    # Wrap the inputs in a <fieldset> and a <ol> tag.
     def call(form, opts)
       super(form, opts){form.tag_(:ol){yield}}
     end
   end
 
-  # Use an ol tag to wrap the inputs.
+  # Use an <ol> tag to wrap the inputs.
   #
   # Registered as :ol.
   class InputsWrapper::OL
     Forme.register_transformer(:inputs_wrapper, :ol, new)
 
-    # Wrap the inputs in an ol tag
+    # Wrap the inputs in an <ol> tag
     def call(form, opts, &block)
-      form.tag(:ol, &block)
+      form.tag(:ol, opts[:attr], &block)
     end
   end
 
-  # Use a div tag to wrap the inputs.
+  # Use a <div> tag to wrap the inputs.
   #
   # Registered as :div.
   class InputsWrapper::Div
     Forme.register_transformer(:inputs_wrapper, :div, new)
 
-    # Wrap the inputs in an ol tag
+    # Wrap the inputs in an <div> tag
+    def call(form, opts, &block)
+      form.tag(:div, opts[:attr], &block)
+    end
+  end
+
+  # Use a <tr> tag to wrap the inputs.
+  #
+  # Registered as :tr.
+  class InputsWrapper::TR
+    Forme.register_transformer(:inputs_wrapper, :tr, new)
+
+    # Wrap the inputs in an <tr> tag
     def call(form, opts, &block)
-      form.tag(:div, &block)
+      form.tag(:tr, opts[:attr], &block)
     end
   end
 
-  # Use a table tag to wrap the inputs.
+  # Use a <table> tag to wrap the inputs.
   #
   # Registered as :table.
   class InputsWrapper::Table
     Forme.register_transformer(:inputs_wrapper, :table, new)
 
-    # Wrap the inputs in a table tag.
+    # Wrap the inputs in a <table> tag.
     def call(form, opts, &block)
-      form.tag(:table, &block)
+      attr = opts[:attr] ? opts[:attr].dup : {}
+      form.tag(:table, attr) do
+        if legend = opts[:legend]
+          form.emit(form.tag(:caption, opts[:legend_attr], legend))
+        end
+
+        if (labels = opts[:labels]) && !labels.empty?
+          form.emit(form.tag(:tr, {}, labels.map{|l| form._tag(:th, {}, l)}))
+        end
+
+        yield
+      end
     end
   end