justinfrench-formtastic 0.1.2 → 0.1.3

data/lib/formtastic.rb

@@ -14,14 +14,28 @@ module Formtastic #:nodoc:
     @@required_string = proc { %{<abbr title="#{I18n.t 'formtastic.required', :default => 'required'}">*</abbr>} }
     @@optional_string = ''
     @@inline_errors = :sentence
-    @@label_str_method = :to_s
+    @@label_str_method = :humanize
     @@collection_label_methods = %w[to_label display_name full_name name title username login value to_s]
     @@inline_order = [ :input, :hints, :errors ]
+    @@file_methods = [ :file?, :public_filename ]
 
-    cattr_accessor :default_text_field_size, :all_fields_required_by_default, :required_string, :optional_string, :inline_errors, :label_str_method, :collection_label_methods, :inline_order
+    cattr_accessor :default_text_field_size, :all_fields_required_by_default, :required_string,
+                   :optional_string, :inline_errors, :label_str_method, :collection_label_methods,
+                   :inline_order, :file_methods
 
-    attr_accessor :template
+    # Keeps simple mappings in a hash
+    #
+    INPUT_MAPPINGS = {
+      :string   => :text_field,
+      :password => :password_field,
+      :numeric  => :text_field,
+      :text     => :text_area,
+      :file     => :file_field
+    }
+    STRING_MAPPINGS = [ :string, :password, :numeric ]
 
+    attr_accessor :template
+    attr_writer   :nested_child_index
 
     # Returns a suitable form input for the given +method+, using the database column information
     # and other factors (like the method name) to figure out what you probably want.
@@ -32,6 +46,7 @@ module Formtastic #:nodoc:
     # * :label - use something other than the method name as the label (or fieldset legend) text
     # * :required - specify if the column is required (true) or not (false)
     # * :hint - provide some text to hint or help the user provide the correct information for a field
+    # * :input_html - provide options that will be passed down to the generated input
     #
     # Input Types:
     #
@@ -39,15 +54,14 @@ module Formtastic #:nodoc:
     # but there are a few special cases and some simplification (:integer, :float and :decimal
     # columns all map to a single numeric_input, for example).
     #
-    # * :select (a select menu for belongs_to associations) - default for columns ending in '_id'
-    # * :radio (a set of radio inputs for belongs_to associations) - alternative for columns ending in '_id'
+    # * :select (a select menu for associations) - default to association names
+    # * :radio (a set of radio inputs for associations) - default to association names
     # * :password (a password input) - default for :string column types with 'password' in the method name
     # * :text (a textarea) - default for :text column types
     # * :date (a date select) - default for :date column types
     # * :datetime (a date and time select) - default for :datetime and :timestamp column types
     # * :time (a time select) - default for :time column types
-    # * :boolean (a checkbox) - default for :boolean column types
-    # * :boolean_select (a yes/no select box)
+    # * :boolean (a checkbox) - default for :boolean column types (you can also have booleans as :select and :radio)
     # * :string (a text field) - default for :string column types
     # * :numeric (a text field, like string) - default for :integer, :float and :decimal column types
     #
@@ -61,29 +75,28 @@ module Formtastic #:nodoc:
     #       <%= form.input :phone, :required => false, :hint => "Eg: +1 555 1234" %>
     #     <% end %>
     #   <% end %>
+    #
     def input(method, options = {})
-      raise NoMethodError.new("NoMethodError: form object does not respond to \"#{method}\"") unless @object.respond_to?(method)
+      options[:required] = method_required?(method, options[:required])
+      options[:as]     ||= default_input_type(method)
 
+      options[:label]  ||= if @object
+        @object.class.human_attribute_name(method.to_s)
+      else
+        method.to_s.send(@@label_str_method)
+      end
 
-      options[:required] = method_required?(method, options[:required])
-      options[:label] ||= @object.class.human_attribute_name(method.to_s).send(@@label_str_method)
-      options[:as] ||= default_input_type(@object, method)
-      input_method = "#{options[:as]}_input"
+      if [:boolean_select, :boolean_radio].include?(options[:as])
+        ::ActiveSupport::Deprecation.warn(":as => :#{options[:as]} is deprecated, use :as => :#{options[:as].to_s[8..-1]} instead", caller[3..-1])
+      end
 
-      html_class = [
-        options[:as].to_s,
-        (options[:required] ? 'required' : 'optional'),
-        (@object.errors.on(method.to_s) ? 'error' : nil)
-      ].compact.join(" ")
+      html_class = [ options[:as], (options[:required] ? :required : :optional) ].join(' ')
+      html_class << ' error' if @object && @object.errors.on(method.to_s)
 
       html_id = generate_html_id(method)
 
       list_item_content = @@inline_order.map do |type|
-        if type == :input
-          send(input_method, method, options)
-        else
-          send(:"inline_#{type}", method, options)
-        end
+        send(:"inline_#{type}_for", method, options)
       end.compact.join("\n")
 
       return template.content_tag(:li, list_item_content, { :id => html_id, :class => html_class })
@@ -221,20 +234,28 @@ module Formtastic #:nodoc:
       html_options[:class] ||= "inputs"
 
       if fields_for_object = html_options.delete(:for)
-        inputs_for_nested_attributes(fields_for_object, args << html_options, &block)
+        html_options.merge!(:parent_builder => self)
+        inputs_for_nested_attributes(fields_for_object, args << html_options,
+                                     html_options.delete(:for_options) || {}, &block)
       elsif block_given?
         field_set_and_list_wrapping(html_options, &block)
       else
-        if args.empty?
-          args  = @object.class.reflections.map { |n,_| n }
+        if @object && args.empty?
+          # Get all belongs_to association
+          args  = @object.class.reflections.map { |n,_| n if _.macro == :belongs_to }
+
+          # Get content columns and remove timestamps columns from it
           args += @object.class.content_columns.map(&:name)
+          args -= %w[created_at updated_at created_on updated_on]
+
+          args.compact!
         end
         contents = args.map { |method| input(method.to_sym) }
 
         field_set_and_list_wrapping(html_options, contents)
       end
     end
-    alias_method :input_field_set, :inputs
+    alias :input_field_set :inputs
 
     # Creates a fieldset and ol tag wrapping for form buttons / actions as list items.
     # See inputs documentation for a full example.  The fieldset's default class attriute
@@ -253,7 +274,7 @@ module Formtastic #:nodoc:
         field_set_and_list_wrapping(html_options, contents)
       end
     end
-    alias_method :button_field_set, :buttons
+    alias :button_field_set :buttons
 
     # Creates a submit input tag with the value "Save [model name]" (for existing records) or
     # "Create [model name]" (for new records) by default:
@@ -263,11 +284,12 @@ module Formtastic #:nodoc:
     # The value of the button text can be overridden:
     #
     #  <%= form.commit_button "Go" %> => <input name="commit" type="submit" value="Go" />
-    def commit_button(value = save_or_create_commit_button_text, options = {})
+    #
+    def commit_button(value=nil, options = {})
+      value ||= save_or_create_button_text
       template.content_tag(:li, template.submit_tag(value), :class => "commit")
     end
 
-
     # A thin wrapper around #fields_for to set :builder => Formtastic::SemanticFormBuilder
     # for nesting forms:
     #
@@ -286,6 +308,7 @@ module Formtastic #:nodoc:
     #       </ol>
     #     </fieldset>
     #   </form>
+    #
     def semantic_fields_for(record_or_name_or_array, *args, &block)
       opts = args.extract_options!
       opts.merge!(:builder => Formtastic::SemanticFormBuilder)
@@ -295,54 +318,68 @@ module Formtastic #:nodoc:
 
     protected
 
-    # Deals with :for option when it's supplied to inputs methods.
+    # Deals with :for option when it's supplied to inputs methods. Additional
+    # options to be passed down to :for should be supplied using :for_options
+    # key.
+    #
     # It should raise an error if a block with arity zero is given.
     #
-    def inputs_for_nested_attributes(fields_for_object, inputs_args, &block)
+    def inputs_for_nested_attributes(fields_for_object, inputs, options, &block)
       fields_for_block = if block_given?
         raise ArgumentError, 'You gave :for option with a block to inputs method, ' <<
                              'but the block does not accept any argument.' if block.arity <= 0
 
-        proc { |f| f.inputs(*inputs_args){ block.call(f) } }
+        proc { |f| f.inputs(*inputs){ block.call(f) } }
       else
-        proc { |f| f.inputs(*inputs_args) }
+        proc { |f| f.inputs(*inputs) }
       end
 
-      semantic_fields_for(*Array(fields_for_object), &fields_for_block)
+      semantic_fields_for(*(Array(fields_for_object) << options), &fields_for_block)
     end
 
-    # Ensure :object => @object is set before sending the options down to the Rails layer.
-    # Also remove any Formtastic-specific options
+    # Remove any Formtastic-specific options before passing the down options.
+    #
     def set_options(options)
-      opts = options.dup
-      [:value_method, :label_method, :collection, :required, :label, :as, :hint].each do |key|
-        opts.delete(key)
-      end
-      opts.merge(:object => @object)
+      options.except(:value_method, :label_method, :collection, :required, :label,
+                     :as, :hint, :input_html, :label_html, :value_as_class)
     end
 
-    def save_or_create_commit_button_text #:nodoc:
-      prefix = @object.new_record? ? 'create' : 'save'
-      [ I18n.t(prefix, :default => prefix, :scope => [:formtastic]),
-        @object.class.human_name
-      ].join(' ').send(@@label_str_method)
+    # Create a default button text. If the form is working with a object, it
+    # defaults to "Create model" or "Save model" depending if we are working
+    # with a new_record or not.
+    #
+    # When not working with models, it defaults to "Submit object".
+    #
+    def save_or_create_button_text(prefix='Submit') #:nodoc:
+      if @object
+        prefix      = @object.new_record? ? 'Create' : 'Save'
+        object_name = @object.class.human_name
+      else
+        object_name = @object_name.to_s.send(@@label_str_method)
+      end
+
+      I18n.t(prefix.downcase, :default => prefix, :scope => [:formtastic]) << ' ' << object_name
     end
 
     # Determins if the attribute (eg :title) should be considered required or not.
     #
     # * if the :required option was provided in the options hash, the true/false value will be
     #   returned immediately, allowing the view to override any guesswork that follows:
+    #
     # * if the :required option isn't provided in the options hash, and the ValidationReflection
     #   plugin is installed (http://github.com/redinger/validation_reflection), true is returned
     #   if the validates_presence_of macro has been used in the class for this attribute, or false
     #   otherwise.
+    #
     # * if the :required option isn't provided, and the plugin isn't available, the value of the
     #   configuration option @@all_fields_required_by_default is used.
+    #
     def method_required?(attribute, required_option) #:nodoc:
       return required_option unless required_option.nil?
 
-      if @object.class.respond_to?(:reflect_on_all_validations)
+      if @object && @object.class.respond_to?(:reflect_on_all_validations)
         attribute_sym = attribute.to_s.sub(/_id$/, '').to_sym
+
         @object.class.reflect_on_all_validations.any? do |validation|
           validation.macro == :validates_presence_of && validation.name == attribute_sym
         end
@@ -351,6 +388,19 @@ module Formtastic #:nodoc:
       end
     end
 
+    # A method that deals with most of inputs (:string, :password, :file,
+    # :textarea and :numeric). :select, :radio, :boolean and :datetime inputs
+    # are not handled by this method, since they need more detailed approach.
+    #
+    # If input_html is given as option, it's passed down to the input.
+    #
+    def input_simple(type, method, options)
+      html_options = options.delete(:input_html) || {}
+      html_options = default_string_options(method).merge(html_options) if STRING_MAPPINGS.include?(type)
+
+      input_label(method, options.delete(:label), options.slice(:required)) + send(INPUT_MAPPINGS[type], method, html_options)
+    end
+
     # Outputs a label and a select box containing options from the parent
     # (belongs_to, has_many, has_and_belongs_to_many) association. If an association
     # is has_many or has_and_belongs_to_many the select box will be set as multi-select
@@ -427,32 +477,23 @@ module Formtastic #:nodoc:
     #
     # Examples:
     #
-    #   f.input :authors, :html => {:size => 20, :multiple => true}
+    #   f.input :authors, :input_html => {:size => 20, :multiple => true}
+    #
     def select_input(method, options)
-      options[:collection] ||= find_parent_objects_for_column(method)
-      options[:label_method] ||= detect_label_method(options[:collection])
-      options[:value_method] ||= :id
-      options[:input_html] ||= {}
-
-      if (reflection = find_reflection(method)) && reflection.macro != :belongs_to
-        options[:input_html][:multiple] ||= true
-        options[:input_html][:size] ||= 5
-      end
+      collection = find_collection_for_column(method, options)
+      html_options = options.delete(:input_html) || {}
 
-      input_name = generate_association_input_name(method)
-      html_options = options.delete(:input_html)
-      choices = formatted_collection(options[:collection], options[:label_method], options[:value_method])
-      input_label(input_name, options) + template.select(@object_name, input_name, choices, set_options(options), html_options)
-    end
+      reflection = find_reflection(method)
+      if reflection && [ :has_many, :has_and_belongs_to_many ].include?(reflection.macro)
+        html_options[:multiple] ||= true
+        html_options[:size]     ||= 5
+       end
 
-    def detect_label_method(collection) #:nodoc:
-      (!collection.instance_of?(Hash)) ? @@collection_label_methods.detect { |m| collection.first.respond_to?(m) } : nil
-    end
-
-    def formatted_collection(collection, label_method, value_method = :id) #:nodoc:
-      return collection if (collection.instance_of?(Hash) || (collection.instance_of?(Array) && collection.first.instance_of?(String)))
-      collection.map { |o| [o.send(label_method), o.send(value_method)] }
+      input_name = generate_association_input_name(method)
+      input_label(input_name, options.delete(:label), options.slice(:required)) +
+      self.select(input_name, collection, set_options(options), html_options)
     end
+    alias :boolean_select_input :select_input
 
     # Outputs a fieldset containing a legend for the label text, and an ordered list (ol) of list
     # items, one for each possible choice in the belongs_to association.  Each li contains a
@@ -500,69 +541,31 @@ module Formtastic #:nodoc:
     #   f.input :author, :as => :radio, :label_method => :label
     #
     # Finally, you can set :value_as_class => true if you want that LI wrappers
-    # contains a class with the wrapped radio input value. This is used by
-    # <tt>boolean_radio_input</tt> and you can see an example there.
+    # contains a class with the wrapped radio input value.
     #
     def radio_input(method, options)
-      options[:collection] ||= find_parent_objects_for_column(method)
-      options[:label_method] ||= detect_label_method(options[:collection])
+      collection   = find_collection_for_column(method, options)
+      html_options = set_options(options).merge(options.delete(:input_html) || {})
 
       input_name = generate_association_input_name(method)
       value_as_class = options.delete(:value_as_class)
 
-      choices = formatted_collection(options[:collection], options[:label_method])
-      template.content_tag(:fieldset,
-        %{<legend><span>#{label_text(method, options)}</span></legend>} +
-        template.content_tag(:ol,
-          choices.map { |c|
-            label = (!c.instance_of?(String)) ? c.first : c
-            value = (!c.instance_of?(String)) ? c.last : c
-
-            li_content = template.content_tag(:label,
-              "#{template.radio_button(@object_name, input_name, value, set_options(options))} #{label}",
-              :for => generate_html_id(input_name, value.to_s.downcase)
-            )
-
-            li_options = value_as_class ? { :class => value.to_s.downcase } : {}
-            template.content_tag(:li, li_content, li_options)
-          }
-        )
-      )
-    end
-
-    # Outputs a label and a password input, nothing fancy.
-    def password_input(method, options)
-      input_label(method, options) +
-      template.password_field(@object_name, method, default_string_options(method))
-    end
-
-
-    # Outputs a label and a textarea, nothing fancy.
-    def text_input(method, options)
-      input_label(method, options) + template.text_area(@object_name, method, set_options(options))
-    end
-
-
-    # Outputs a label and a text input, nothing fancy, but it does pick up some attributes like
-    # size and maxlength -- see default_string_options() for the low-down.
-    def string_input(method, options)
-      input_label(method, options) +
-      template.text_field(@object_name, method, default_string_options(method))
-    end
+      list_item_content = collection.map do |c|
+        label = c.is_a?(Array) ? c.first : c
+        value = c.is_a?(Array) ? c.last  : c
 
+        li_content = template.content_tag(:label,
+          "#{self.radio_button(input_name, value, html_options)} #{label}",
+          :for => generate_html_id(input_name, value.to_s.downcase)
+        )
 
-    # Same as string_input for now
-    def numeric_input(method, options)
-      input_label(method, options) +
-      template.text_field(@object_name, method, default_string_options(method))
-    end
+        li_options = value_as_class ? { :class => value.to_s.downcase } : {}
+        template.content_tag(:li, li_content, li_options)
+      end
 
-    # Outputs label and file field
-    def file_input(method, options)
-      input_label(method, options) +
-      template.file_field(@object_name, method, set_options(options))
+      field_set_and_list_wrapping_for_method(method, options, list_item_content)
     end
-
+    alias :boolean_radio_input :radio_input
 
     # Outputs a fieldset with a legend for the method label, and a ordered list (ol) of list
     # items (li), one for each fragment for the date (year, month, day).  Each li contains a label
@@ -629,118 +632,97 @@ module Formtastic #:nodoc:
     #
     def date_or_datetime_input(method, options)
       position = { :year => 1, :month => 2, :day => 3, :hour => 4, :minute => 5, :second => 6 }
-      inputs = options.delete(:order) || I18n.translate(:'date.order') || [:year, :month, :day]
+      inputs   = options.delete(:order) || I18n.translate(:'date.order') || [:year, :month, :day]
+
       time_inputs = [:hour, :minute]
       time_inputs << [:second] if options[:include_seconds]
 
+      list_items_capture = ""
+
       # Gets the datetime object. It can be a Fixnum, Date or Time, or nil.
-      datetime = @object.send(method)
+      datetime     = @object ? @object.send(method) : nil
+      html_options = options.delete(:input_html) || {}
 
-      list_items_capture = ""
       (inputs + time_inputs).each do |input|
-        html_id = generate_html_id(method, "#{position[input]}i")
+        html_id    = generate_html_id(method, "#{position[input]}i")
+        field_name = "#{method}(#{position[input]}i)"
 
-        if options["discard_#{input}".intern]
+        list_items_capture << if options["discard_#{input}".intern]
           break if time_inputs.include?(input)
+
           hidden_value = datetime.respond_to?(input) ? datetime.send(input) : datetime
-          list_items_capture << template.hidden_field_tag("#{@object_name}[#{method}(#{position[input]}i)]", (hidden_value || 1), :id => html_id)
+          template.hidden_field_tag("#{@object_name}[#{field_name}]", (hidden_value || 1), :id => html_id)
         else
-          opts = set_options(options).merge(:prefix => @object_name, :field_name => "#{method}(#{position[input]}i)")
-          item_label_text = I18n.t(input.to_s, :default => input.to_s, :scope => [:formtastic]).send(@@label_str_method)
-          list_items_capture << template.content_tag(:li,
+          opts = set_options(options).merge(:prefix => @object_name, :field_name => field_name)
+          item_label_text = I18n.t(input.to_s, :default => input.to_s.humanize, :scope => [:datetime, :prompts])
+
+          template.content_tag(:li,
             template.content_tag(:label, item_label_text, :for => html_id) +
-            template.send("select_#{input}".intern, @object.send(method), opts)
+            template.send("select_#{input}".intern, datetime, opts, html_options.merge(:id => html_id))
           )
         end
       end
 
-      template.content_tag(:fieldset,
-        %{<legend><span>#{label_text(method, options)}</span></legend>} +
-        template.content_tag(:ol, list_items_capture)
-      )
+      field_set_and_list_wrapping_for_method(method, options, list_items_capture)
     end
 
-    # Outputs a label containing a checkbox and the label text.  The label defaults to the column
-    # name (method name) and can be altered with the :label option.
+    # Outputs a label containing a checkbox and the label text. The label defaults
+    # to the column name (method name) and can be altered with the :label option.
+    #
+    # Different from other inputs, :required options has no effect here and
+    # :checked_value and :unchecked_value options are also available.
+    #
     def boolean_input(method, options)
-      input_label(method, options,
-        template.check_box(@object_name, method, set_options(options)) +
-        label_text(method, options)
-      )
+      html_options = options.delete(:input_html) || {}
+
+      content = self.check_box(method, set_options(options).merge(html_options),
+                               options.delete(:checked_value) || '1', options.delete(:unchecked_value) || '0')
+
+      # required does not make sense in check box
+      input_label(method, content + options.delete(:label), :skip_required => true)
     end
 
-    # Outputs a label and select box containing two options for "true" and "false". The visible
-    # text defaults to "Yes" and "No" respectively, but can be altered with the :true and :false
-    # options.  The label text to the column name (method name), but can be altered with the
-    # :label option. Example:
-    #
-    #  f.input :awesome, :as => :boolean_select, :true => "Yeah!", :false => "Nah!", :label => "Make this sucker public?"
+    # Generates an input for the given method using the type supplied with :as.
     #
-    # Returns something like:
+    # If the input is included in INPUT_MAPPINGS, it uses input_simple
+    # implementation which maps most of the inputs. All others have specific
+    # code and then a proper handler should be called (like radio_input) for
+    # :radio types.
     #
-    #  <li class="boolean_select required" id="post_public_input">
-    #    <label for="post_public">
-    #      Make this sucker public?<abbr title="required">*</abbr>
-    #    </label>
-    #    <select id="post_public" name="post[public]">
-    #      <option value="1">Yeah!</option>
-    #      <option value="0">Nah!</option>
-    #    </select>
-    #  </li>
-    #
-    def boolean_select_input(method, options)
-      options[:true]  ||= I18n.t('yes', :default => 'Yes', :scope => [:formtastic]).send(@@label_str_method)
-      options[:false] ||= I18n.t('no', :default => 'No', :scope => [:formtastic]).send(@@label_str_method)
+    def inline_input_for(method, options)
+      input_type = options.delete(:as)
 
-      choices = [ [options.delete(:true),true], [options.delete(:false),false] ]
-      input_label(method, options) + template.select(@object_name, method, choices, set_options(options))
+      if INPUT_MAPPINGS.key?(input_type)
+        input_simple(input_type,  method, options)
+      else
+        send("#{input_type}_input", method, options)
+      end
     end
 
-    # Outputs a fieldset containing two radio buttons (with labels) for "true" and "false". The
-    # visible label text for each option defaults to "Yes" and "No" respectively, but can be
-    # altered with the :true and :false options.  The fieldset legend defaults to the column name
-    # (method name), but can be altered with the :label option.  Example:
-    #
-    #  f.input :awesome, :as => :boolean_radio, :true => "Yeah!", :false => "Nah!", :label => "Awesome?"
-    #
-    # Returns something like:
+    # Generates error messages for the given method. Errors can be shown as list
+    # or as sentence. If :none is set, no error is shown.
     #
-    #  <li class="boolean_radio required" id="post_public_input">
-    #    <fieldset><legend><span>make this sucker public?<abbr title="required">*</abbr></span></legend>
-    #      <ol>
-    #        <li class="true">
-    #          <label for="post_public_true">
-    #            <input id="post_public_true" name="post[public]" type="radio" value="true" /> Yeah!
-    #          </label>
-    #        </li>
-    #        <li class="false">
-    #          <label for="post_public_false">
-    #            <input id="post_public_false" name="post[public]" type="radio" checked="checked" /> Nah!
-    #          </label>
-    #        </li>
-    #      </ol>
-    #    </fieldset>
-    #  </li>
-    #
-    def boolean_radio_input(method, options)
-      options[:true]  ||= I18n.t('yes', :default => 'Yes', :scope => [:formtastic]).send(@@label_str_method)
-      options[:false] ||= I18n.t('no', :default => 'No', :scope => [:formtastic]).send(@@label_str_method)
+    def inline_errors_for(method, options)  #:nodoc:
+      return nil unless @object && [:sentence, :list].include?(@@inline_errors)
 
-      choices = { options.delete(:true) => true, options.delete(:false) => false }
-      radio_input(method, { :collection => choices, :value_as_class => true }.merge(options))
+      errors = @object.errors.on(method.to_s).to_a
+      send("error_#{@@inline_errors}", errors) unless errors.empty?
     end
 
-    def inline_errors(method, options)  #:nodoc:
-      errors = @object.errors.on(method.to_s).to_a
-      unless errors.empty?
-        send("error_#{@@inline_errors}", errors) if [:sentence, :list].include?(@@inline_errors)
-      end
+    # Generates hints for the given method using the text supplied in :hint.
+    #
+    def inline_hints_for(method, options) #:nodoc:
+      options[:hint].blank? ? '' : template.content_tag(:p, options[:hint], :class => 'inline-hints')
     end
 
+    # Creates an error sentence by calling to_sentence on the errors array.
+    #
     def error_sentence(errors) #:nodoc:
       template.content_tag(:p, errors.to_sentence, :class => 'inline-errors')
     end
 
+    # Creates an error li list.
+    #
     def error_list(errors) #:nodoc:
       list_elements = []
       errors.each do |error|
@@ -749,19 +731,24 @@ module Formtastic #:nodoc:
       template.content_tag(:ul, list_elements.join("\n"), :class => 'errors')
     end
 
-    def inline_hints(method, options) #:nodoc:
-      options[:hint].blank? ? '' : template.content_tag(:p, options[:hint], :class => 'inline-hints')
-    end
-
-    def label_text(method, options) #:nodoc:
-      [ options[:label], required_or_optional_string(options[:required]) ].join()
-    end
+    # Generates the label for the input. Accepts the same options as Rails label
+    # method and a fourth option that allows the label to be generated as span
+    # with class label.
+    #
+    def input_label(method, text, options={}, as_span=false) #:nodoc:
+      text << required_or_optional_string(options.delete(:required)) unless options.delete(:skip_required)
 
-    def input_label(method, options, text = nil) #:nodoc:
-      text ||= label_text(method, options)
-      template.label(@object_name, method, text, set_options(options))
+      if as_span
+        options[:class] ||= 'label'
+        template.content_tag(:span, text, options)
+      else
+        self.label(method, text, options)
+      end
     end
 
+    # Generates the required or optional string. If the value set is a proc,
+    # it evaluates the proc first.
+    #
     def required_or_optional_string(required) #:nodoc:
       string_or_proc = required ? @@required_string : @@optional_string
 
@@ -772,24 +759,46 @@ module Formtastic #:nodoc:
       end
     end
 
-    def field_set_and_list_wrapping(field_set_html_options, contents = '', &block) #:nodoc:
-      legend_text = field_set_html_options.delete(:name)
+    # Generates a fieldset and wraps the content in an ordered list. When working
+    # with nested attributes (in Rails 2.3), it allows %i as interpolation option
+    # in :name. So you can do:
+    #
+    #   f.inputs :name => 'Task #%i', :for => :tasks
+    #
+    # And it will generate a fieldset for each task with legend 'Task #1', 'Task #2',
+    # 'Task #3' and so on.
+    #
+    # If you are using inputs :for, for more than one association in the same
+    # form builder, you might want to set the nested_child_index as well. You
+    # can do that doing:
+    #
+    #   f.nested_child_index = -1
+    #
+    def field_set_and_list_wrapping(html_options, contents = '', &block) #:nodoc:
+      # Generates the legend text allowing nested_child_index support for interpolation
+      legend_text  = html_options.delete(:name).to_s
+      legend_text %= html_options[:parent_builder].instance_variable_get('@nested_child_index').to_i + 1
+
       legend = legend_text.blank? ? "" : template.content_tag(:legend, template.content_tag(:span, legend_text))
-      if block_given?
-        contents = template.capture(&block)
-        template.concat(
-          template.content_tag(:fieldset,
-            legend + template.content_tag(:ol, contents),
-            field_set_html_options
-          )
-        )
-      else
-        template.content_tag(:fieldset,
-          legend + template.content_tag(:ol, contents),
-          field_set_html_options
-        )
-      end
+      contents = template.capture(&block) if block_given?
+
+      fieldset = template.content_tag(:fieldset,
+        legend + template.content_tag(:ol, contents),
+        html_options.except(:builder, :parent_builder)
+      )
 
+      template.concat(fieldset) if block_given?
+      fieldset
+    end
+
+    # Also generates a fieldset and an ordered list but with label based in
+    # method. This methods is currently used by radio and datetime inputs.
+    #
+    def field_set_and_list_wrapping_for_method(method, options, contents)
+      template.content_tag(:fieldset,
+        %{<legend>#{input_label(method, options.delete(:label), options.slice(:required), true)}</legend>} +
+        template.content_tag(:ol, contents)
+      )
     end
 
     # For methods that have a database column, take a best guess as to what the inout method
@@ -799,46 +808,99 @@ module Formtastic #:nodoc:
     #
     # If there is no column for the method (eg "virtual columns" with an attr_accessor), the
     # default is a :string, a similar behaviour to Rails' scaffolding.
-    def default_input_type(object, method) #:nodoc:
+    #
+    def default_input_type(method) #:nodoc:
+      return :string if @object.nil?
+
       # Find the column object by attribute
-      column = object.column_for_attribute(method) if object.respond_to?(:column_for_attribute)
-      # Maybe the column is a reflection?
-      column = find_reflection(method) unless column
+      column = @object.column_for_attribute(method) if @object.respond_to?(:column_for_attribute)
+
+      # Associations map by default to a select
+      return :select if column.nil? && find_reflection(method)
 
       if column
         # handle the special cases where the column type doesn't map to an input method
-        return :select if column.respond_to?(:macro) && column.respond_to?(:klass)
-        return :select if column.type == :integer && method.to_s =~ /_id$/
+        return :select   if column.type == :integer && method.to_s =~ /_id$/
         return :datetime if column.type == :timestamp
-        return :numeric if [:integer, :float, :decimal].include?(column.type)
+        return :numeric  if [:integer, :float, :decimal].include?(column.type)
         return :password if column.type == :string && method.to_s =~ /password/
         # otherwise assume the input name will be the same as the column type (eg string_input)
         return column.type
       else
-        obj = object.send(method)
-        return :file if [:file?, :public_filename].any? { |m| obj.respond_to?(m) }
+        obj = @object.send(method) if @object.respond_to?(method)
+
+        return :file     if obj && @@file_methods.any? { |m| obj.respond_to?(m) }
         return :password if method.to_s =~ /password/
         return :string
       end
     end
 
-    # Used by association inputs (select, radio) to get a default collection from the parent object
-    # by determining the classname from the method/column name (section_id => Section) and doing a
-    # simple find(:all).
-    def find_parent_objects_for_column(column)
-      parent_class = if reflection = find_reflection(column)
-        reflection.klass
+    # Used by select and radio inputs. The collection can be retrieved by
+    # three ways:
+    #
+    # * Explicitly provided through :collection
+    # * Retrivied through an association
+    # * Or a boolean column, which will generate a localized { "Yes" => true, "No" => false } hash.
+    #
+    # If the collection is not a hash or an array of strings, fixnums or arrays,
+    # we use label_method and value_method to retreive an array with the
+    # appropriate label and value.
+    #
+    def find_collection_for_column(column, options)
+      reflection = find_reflection(column)
+
+      collection = if options[:collection]
+        options.delete(:collection)
+      elsif reflection || column.to_s =~ /_id$/
+        parent_class = if reflection
+          reflection.klass
+        else
+          ::ActiveSupport::Deprecation.warn("The _id way of doing things is deprecated. Please use the association method (#{column.to_s.sub(/_id$/,'')})", caller[3..-1])
+          column.to_s.sub(/_id$/,'').camelize.constantize
+        end
+
+        parent_class.find(:all)
       else
-        ::ActiveSupport::Deprecation.warn("The _id way of doing things is deprecated. Please use the association method (#{column.to_s.sub(/_id$/,'')})", caller[3..-1])
-        column.to_s.sub(/_id$/,'').camelize.constantize
+        create_boolean_collection(options)
       end
-      parent_class.find(:all)
+
+      collection = collection.to_a if collection.instance_of?(Hash)
+
+      # Return if we have an Array of strings, fixnums or arrays
+      return collection if collection.instance_of?(Array) &&
+                           [Array, Fixnum, String, Symbol].include?(collection.first.class)
+
+      label = options.delete(:label_method) || detect_label_method(collection)
+      value = options.delete(:value_method) || :id
+
+      collection.map { |o| [o.send(label), o.send(value)] }
     end
 
-    # Used by association inputs (select, radio) to generate the name that should be used for the input
-    # belongs_to :author; f.input :author; will generate 'author_id'
-    # has_many :authors; f.input :authors; will generate 'author_ids'
-    # has_and_belongs_to_many will act like has_many
+    # Detected the label collection method when none is supplied using the
+    # values set in @@collection_label_methods.
+    #
+    def detect_label_method(collection) #:nodoc:
+      @@collection_label_methods.detect { |m| collection.first.respond_to?(m) }
+    end
+
+    # Returns a hash to be used by radio and select inputs when a boolean field
+    # is provided.
+    #
+    def create_boolean_collection(options)
+      options[:true] ||= I18n.t('yes', :default => 'Yes', :scope => [:formtastic])
+      options[:false] ||= I18n.t('no', :default => 'No', :scope => [:formtastic])
+      options[:value_as_class] = true unless options.key?(:value_as_class)
+
+      { options.delete(:true) => true, options.delete(:false) => false }
+    end
+
+    # Used by association inputs (select, radio) to generate the name that should
+    # be used for the input
+    #
+    #   belongs_to :author; f.input :author; will generate 'author_id'
+    #   has_many :authors; f.input :authors; will generate 'author_ids'
+    #   has_and_belongs_to_many will act like has_many
+    #
     def generate_association_input_name(method)
       if reflection = find_reflection(method)
         method = "#{method.to_s.singularize}_id"
@@ -847,25 +909,24 @@ module Formtastic #:nodoc:
       method
     end
 
-    # If an association method is passed in (f.input :author) try to find the reflection object
+    # If an association method is passed in (f.input :author) try to find the
+    # reflection object.
+    #
     def find_reflection(method)
       object.class.reflect_on_association(method) if object.class.respond_to?(:reflect_on_association)
     end
 
+    # Generates default_string_options by retrieving column information from
+    # the database.
+    #
     def default_string_options(method) #:nodoc:
-      # Use rescue to set column if @object does not have a column_for_attribute method
-      # (eg if @object is not an ActiveRecord object)
-      begin
-        column = @object.column_for_attribute(method)
-      rescue NoMethodError
-        column = nil
-      end
-      opts = if column.nil? || column.limit.nil?
+      column = @object.column_for_attribute(method) if @object.respond_to?(:column_for_attribute)
+
+      if column.nil? || column.limit.nil?
         { :size => @@default_text_field_size }
       else
         { :maxlength => column.limit, :size => [column.limit, @@default_text_field_size].min }
       end
-      set_options(opts)
     end
 
     # Generate the html id for the li tag.
@@ -931,6 +992,7 @@ module Formtastic #:nodoc:
   # Please note: Although it's possible to call Rails' built-in form_for() helper without an
   # object, all semantic forms *must* have an object (either Post.new or @post), as Formtastic
   # has too many dependencies on an ActiveRecord object being present.
+  #
   module SemanticFormHelper
     @@builder = Formtastic::SemanticFormBuilder