nofxx-formtastic 0.1.8 → 0.1.9

data/README.textile

@@ -1,4 +1,4 @@
-h1. Formtastic 0.1.4
+h1. Formtastic
 
 Formtastic is a Rails FormBuilder DSL (with some other goodies) to make it far easier to create beautiful, semantically rich, syntactically awesome, readily stylable and wonderfully accessible HTML forms in your Rails applications.
 
@@ -89,8 +89,7 @@ And then add it as a dependency in your environment.rb file:
 <pre>
   config.gem "justinfrench-formtastic",
     :lib     => 'formtastic',
-    :source  => 'http://gems.github.com',
-    :version => '0.1.4'
+    :source  => 'http://gems.github.com'
 </pre>
 
 If you're a little more old school, install it as a plugin:
@@ -103,7 +102,7 @@ h2. Usage
 
 Forms are really boring to code... you want to get onto the good stuff as fast as possible.
 
-This renders a set of inputs (one for _most_ columns in the database table, and one for each ActiveRecord belongs_to, has_many or has_and_belongs_to_many association) and a submit button:
+This renders a set of inputs (one for _most_ columns in the database table, and one for each ActiveRecord belongs_to association), followed by a submit button:
 
 <pre>
   <% semantic_form_for @user do |form| %>
@@ -138,7 +137,7 @@ If you want control over the input type Formtastic uses for each field, you can
   <% end %>
 </pre>
 
-If you want to customize the label text, or render some hint text below the field, specify which fields are required/option, or break the form into two fieldsets, the DSL is pretty comprehensive:
+If you want to customize the label text, or render some hint text below the field, specify which fields are required/optional, or break the form into two fieldsets, the DSL is pretty comprehensive:
 
 <pre>
   <% semantic_form_for @post do |form| %>
@@ -159,18 +158,6 @@ If you want to customize the label text, or render some hint text below the fiel
   <% end %>
 </pre>
 
-If you want to customize html elements for any non button inputs and the li
-wrapper you just need to specify the :input_html and :wrapper_html options hash.
-
-<pre>
-    <% semantic_form_for @post do |form| %>
-      <%= form.input :title, :input_html => {:size => 60} %>
-      <%= form.input :body, :wrapper_html => { :class => 'body_wrapper' } %>
-      <%= form.input :created_at, :input_html => {:disabled => true} %>
-      <%= form.buttons %>
-    <% end %>
-</pre>
-
 To customize buttons, :button_html is available.
 
 Nested forms (Rails 2.3) are also supported. You can do it in the Rails way:
@@ -178,29 +165,24 @@ Nested forms (Rails 2.3) are also supported. You can do it in the Rails way:
 <pre>
   <% semantic_form_for @post do |form| %>
     <%= form.inputs :title, :body, :created_at %>
-
     <% form.semantic_fields_for :author do |author| %>
       <%= author.inputs :first_name, :last_name, :name => 'Author' %>
     <% end %>
-
     <%= form.buttons %>
   <% end %>
 </pre>
 
-Or in the formtastic way:
+Or the Formtastic way with the @:for@ option:
 
 <pre>
   <% semantic_form_for @post do |form| %>
     <%= form.inputs :title, :body, :created_at %>
-
     <%= form.inputs :first_name, :last_name, :for => :author, :name => "Author" %>
-
     <%= form.buttons %>
   <% end %>
 </pre>
 
-When working in has many association, you can even supply "%i" in your fieldset
-name that it will be properly interpolated with the child index. For example:
+When working in has many association, you can even supply "%i" in your fieldset name that it will be properly interpolated with the child index. For example:
 
 <pre>
   <% semantic_form_for @post do |form| %>
@@ -210,23 +192,60 @@ name that it will be properly interpolated with the child index. For example:
   <% end %>
 </pre>
 
-Each category will be wrapped in a fieldset with legend "Category #1",
-"Category #2" and so on. But please notice that this works only with Rails 2.3.
+
+Customize HTML attributes for any input using the @:input_html@ option.  Typically his is used to disable the input, change the size of a text field, change the rows in a textarea, or even to add a special class to an input to attach special behavior like "autogrow":http://plugins.jquery.com/project/autogrow textareas:
+
+<pre>
+  <% semantic_form_for @post do |form| %>
+    <%= form.input :title,      :input_html => { :size => 60 } %>
+    <%= form.input :body,       :input_html => { :class => 'autogrow' } %>
+    <%= form.input :created_at, :input_html => { :disabled => true } %>
+    <%= form.buttons %>
+  <% end %>
+</pre>
+
+The same can be done for buttons with the @:button_html@ option:
+
+<pre>
+  <% semantic_form_for @post do |form| %>
+    ...
+    <% form.buttons do %>
+      <%= form.commit_button :button_html => { :class => "primary" } %>
+    <% end %>
+  <% end %>
+</pre>
+
+Customize the HTML attributes for the @<li>@ wrapper around every input with the @:wrapper_html@ option hash.  There's one special key in the hash (:class), which will actually _append_ your string of classes to the existing classes provided by Formtastic (like "required string error")
+
+<pre>
+  <% semantic_form_for @post do |form| %>
+    <%= form.input :title, :wrapper_html => { :class => "important" } %>
+    <%= form.input :body %>
+    <%= form.input :description, :wrapper_html => { :style => "display:none;" } %>
+    ...
+  <% end %>
+</pre>
+
+
 
 h2. The Available Inputs
 
 * :select (a select menu) - default for ActiveRecord associations (belongs_to, has_many, has_and_belongs_to_many)
+* :check_boxes (a set of check_box inputs) - alternative to :select has_many and has_and_belongs_to_many associations
 * :radio (a set of radio inputs) - alternative to :select for ActiveRecord belongs_to associations
+* :time_zone (a select input) - default for :string column types with 'time_zone' in the method name
 * :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)
 * :string (a text field) - default for :string column types
 * :numeric (a text field, like string) - default for :integer, :float and :decimal column types
 * :file (a file field) - default for paperclip or attachment_fu attributes
+* :country (a select menu of country names) - default for :string columns named "country", requires a country_select plugin to be installed
+* :hidden (a hidden field) - creates a hidden field (added for compatibility)
+
 
 The documentation is pretty good for each of these (what it does, what the output is, what the options are, etc) so go check it out.
 
@@ -273,6 +292,9 @@ If you wish, put something like this in config/initializers/formtastic_config.rb
   # the input, in the following order: hints, input and errors. You can
   # customize it doing just as below:
   Formtastic::SemanticFormBuilder.inline_order = [:hints, :input, :errors]
+  
+  # Set the default "priority countries" to suit your user base when using :as => :country
+  Formtastic::SemanticFormBuilder.priority_countries = ["Australia", "New Zealand"]
 </pre>
 
 
@@ -302,6 +324,7 @@ h2. Dependencies
 There are none, but...
 
 * if you have the "ValidationReflection":http://github.com/redinger/validation_reflection plugin is installed, you won't have to specify the :required option (it checks the validations on the model instead)
+* if you want to use the :country input, you'll need to install the "iso-3166-country-select plugin":http://github.com/rails/iso-3166-country-select (or any other country_select plugin with the same API)
 * rspec, rspec_hpricot_matchers and rcov gems (plus any of their own dependencies) are required for the test suite
 
 
@@ -331,10 +354,8 @@ A proof-of-concept (very much a work-in-progress) stylesheet is provided which y
 
 h2. Contributors
 
-Formtastic wouldn't be as awesome as it is today if it weren't for the wonderful contributions of these fine, fine coders.  An extra huge thanks goes out to "José Valim":http://github.com/josevalim for nearly 50 patches.
+Formtastic is maintained by "Justin French":http://justinfrench.com and "José Valim":http://github.com/josevalim, but it wouldn't be as awesome as it is today if it weren't for the wonderful contributions of these fine, fine coders.
 
-* "Justin French":http://justinfrench.com
-* "José Valim":http://github.com/josevalim
 * "Jeff Smick":http://github.com/sprsquish
 * "Tien Dung":http://github.com/tiendung
 * "Mark Mansour":http://stateofflux.com

data/generators/formtastic_stylesheets/templates/formtastic.css

@@ -10,8 +10,10 @@ This stylesheet forms part of the Formtastic Rails Plugin
 --------------------------------------------------------------------------------------------------*/
 
 
-/* NORMALIZE AND RESET - obviously inspired by Yahoo's reset.css, but scoped to just form.formtastic
+/* NORMALIZE AND RESET
 --------------------------------------------------------------------------------------------------*/
+
+/* obviously inspired by Yahoo's reset.css, but scoped to just form.formtastic elements that we care about */
 form.formtastic, form.formtastic ul, form.formtastic ol, form.formtastic li, form.formtastic fieldset, form.formtastic legend, form.formtastic input, form.formtastic textarea, form.formtastic select, form.formtastic p { margin:0; padding:0; }
 form.formtastic fieldset { border:0; }
 form.formtastic em, form.formtastic strong { font-style:normal; font-weight:normal; }
@@ -21,12 +23,16 @@ form.formtastic input, form.formtastic textarea, form.formtastic select { font-f
 form.formtastic input, form.formtastic textarea, form.formtastic select { font-size:100%; }
 form.formtastic legend { color:#000; }
 
+/* Rails wraps error fields with divs */
+div.fieldWithErrors { display:inline; margin:0; padding:0; }
+
 
 /* FIELDSETS & LISTS
 --------------------------------------------------------------------------------------------------*/
+
 form.formtastic fieldset { }
-form.formtastic fieldset.inputs { }
-form.formtastic fieldset.buttons { padding-left:25%; }
+form.formtastic fieldset.inputs { border-top:1px solid #eee; }
+form.formtastic fieldset.buttons { padding:10px; }
 form.formtastic fieldset ol { }
 
 /* clearfixing the fieldsets */
@@ -38,7 +44,8 @@ html[xmlns] form.formtastic fieldset { display: block; }
 
 /* INPUT LIs
 --------------------------------------------------------------------------------------------------*/
-form.formtastic fieldset ol li { margin-bottom:1.5em; }
+
+form.formtastic fieldset ol li { border-bottom:1px solid #eee; padding:5px; }
 
 /* clearfixing the li's */
 form.formtastic fieldset ol li { display: inline-block; }
@@ -53,12 +60,9 @@ form.formtastic fieldset ol li.error { }
 
 /* LABELS
 --------------------------------------------------------------------------------------------------*/
-form.formtastic fieldset ol li label { display:block; width:25%; float:left; padding-top:.2em; }
-form.formtastic fieldset ol li li label { line-height:100%; padding-top:0; }
-form.formtastic fieldset ol li li label input { line-height:100%; vertical-align:middle; margin-top:-0.1em;}
 
 
-/* NESTED FIELDSETS AND LEGENDS (radio and date/time inputs use nested fieldsets)
+/* NESTED FIELDSETS AND LEGENDS (radio, check boxes and date/time inputs use nested fieldsets)
 --------------------------------------------------------------------------------------------------*/
 form.formtastic fieldset ol li fieldset { position:relative; }
 form.formtastic fieldset ol li fieldset legend { position:absolute; width:25%; padding-top:0.1em; }
@@ -66,6 +70,7 @@ form.formtastic fieldset ol li fieldset legend span { position:absolute; }
 form.formtastic fieldset ol li fieldset ol { float:left; width:74%; margin:0; padding:0 0 0 25%; }
 form.formtastic fieldset ol li fieldset ol li { padding:0; border:0; }
 
+
 /* INLINE HINTS
 --------------------------------------------------------------------------------------------------*/
 form.formtastic fieldset ol li p.inline-hints { color:#666; margin:0.5em 0 0 25%; }
@@ -73,42 +78,65 @@ form.formtastic fieldset ol li p.inline-hints { color:#666; margin:0.5em 0 0 25%
 
 /* INLINE ERRORS
 --------------------------------------------------------------------------------------------------*/
-form.formtastic fieldset ol li p.inline-errors { color:#cc0000; margin:0.5em 0 0 25%; }
-form.formtastic fieldset ol li ul.errors { color:#cc0000; margin:0.5em 0 0 25%; list-style:square; }
+form.formtastic fieldset ol li p.inline-errors { color:red; margin:0.5em 0 0 25%; }
+form.formtastic fieldset ol li ul.errors { color:red; margin:0.5em 0 0 25%; list-style:square; }
 form.formtastic fieldset ol li ul.errors li { padding:0; border:none; display:list-item; }
 
-
 /* STRING & NUMERIC OVERRIDES
 --------------------------------------------------------------------------------------------------*/
 form.formtastic fieldset ol li.string input { width:74%; }
 form.formtastic fieldset ol li.numeric input { width:74%; }
 
-
 /* TEXTAREA OVERRIDES
 --------------------------------------------------------------------------------------------------*/
 form.formtastic fieldset ol li.text textarea { width:74%; }
-
-
-/* CHECKBOX OVERRIDES
---------------------------------------------------------------------------------------------------*/
 form.formtastic fieldset ol li.boolean label { padding-left:25%; width:auto; }
 form.formtastic fieldset ol li.boolean label input { margin:0 0.5em 0 0.2em; }
 
 
-/* RADIO OVERRIDES
+/* BELONGS_TO (RADIO) OVERRIDES
 --------------------------------------------------------------------------------------------------*/
-form.formtastic fieldset ol li.radio { }
-form.formtastic fieldset ol li.radio fieldset ol { margin-bottom:-0.6em; }
-form.formtastic fieldset ol li.radio fieldset ol li { margin:0.1em 0 0.5em 0; }
+form.formtastic fieldset ol li.radio fieldset { }
+form.formtastic fieldset ol li.radio fieldset legend { display:block; float:left; width:25%; position:relative; }
+form.formtastic fieldset ol li.radio fieldset legend span { }
+form.formtastic fieldset ol li.radio fieldset ol { float:left; width:74%; }
+form.formtastic fieldset ol li.radio fieldset ol li { padding:0; border:0; margin-bottom:.2em; }
 form.formtastic fieldset ol li.radio fieldset ol li label { float:none; width:100%; }
-form.formtastic fieldset ol li.radio fieldset ol li label input { margin-right:0.2em; }
+form.formtastic fieldset ol li.radio fieldset ol li label input { margin-right:0.5em; }
+
+
+/* CHECK BOXES (COLLECTION) OVERRIDES
+--------------------------------------------------------------------------------------------------*/
+form.formtastic fieldset ol li.check_boxes { }
+form.formtastic fieldset ol li.check_boxes fieldset ol { margin-bottom:-0.6em; }
+form.formtastic fieldset ol li.check_boxes fieldset ol li { margin:0.1em 0 0.5em 0; }
+form.formtastic fieldset ol li.check_boxes fieldset ol li label { float:none; width:100%; }
+form.formtastic fieldset ol li.check_boxes fieldset ol li label input { margin-right:0.2em; }
+
 
 
 /* DATE & TIME OVERRIDES
 --------------------------------------------------------------------------------------------------*/
+
+form.formtastic fieldset ol li.date fieldset,
+form.formtastic fieldset ol li.time fieldset,
+form.formtastic fieldset ol li.datetime fieldset {}
+
+form.formtastic fieldset ol li.date fieldset legend,
+form.formtastic fieldset ol li.time fieldset legend,
+form.formtastic fieldset ol li.datetime fieldset legend { display:block; float:left; width:25%; position:relative; }
+
+form.formtastic fieldset ol li.date fieldset legend span,
+form.formtastic fieldset ol li.time fieldset legend span,
+form.formtastic fieldset ol li.datetime fieldset legend span {  }
+
+form.formtastic fieldset ol li.date fieldset ol,
+form.formtastic fieldset ol li.time fieldset ol,
+form.formtastic fieldset ol li.datetime fieldset ol { float:left; width:74%; margin:0; padding:0; }
+
 form.formtastic fieldset ol li.date fieldset ol li,
 form.formtastic fieldset ol li.time fieldset ol li,
-form.formtastic fieldset ol li.datetime fieldset ol li { float:left; width:auto; margin:0 .3em 0 0; }
+form.formtastic fieldset ol li.datetime fieldset ol li { float:left; width:auto; margin:0 .3em 0 0; padding:0; border:0; }
 
 form.formtastic fieldset ol li.date fieldset ol li label,
 form.formtastic fieldset ol li.time fieldset ol li label,
@@ -116,4 +144,4 @@ form.formtastic fieldset ol li.datetime fieldset ol li label { display:none; }
 
 form.formtastic fieldset ol li.date fieldset ol li label input,
 form.formtastic fieldset ol li.time fieldset ol li label input,
-form.formtastic fieldset ol li.datetime fieldset ol li label input { display:inline; margin:0; padding:0;  }
+form.formtastic fieldset ol li.datetime fieldset ol li label input { display:inline; margin:0; padding:0;  }

data/lib/formtastic.rb

@@ -18,13 +18,13 @@ module Formtastic #:nodoc:
     @@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 ]
+    @@priority_countries = ["Australia", "Canada", "United Kingdom", "United States"]
 
     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
+                   :inline_order, :file_methods, :priority_countries
 
     # Keeps simple mappings in a hash
-    #
     INPUT_MAPPINGS = {
       :string   => :text_field,
       :password => :password_field,
@@ -42,7 +42,7 @@ module Formtastic #:nodoc:
     # Options:
     #
     # * :as - override the input type (eg force a :string to render as a :password field)
-    # * :label - use something other than the method name as the label (or fieldset legend) text
+    # * :label - use something other than the method name as the label text, when false no label is printed
     # * :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
@@ -55,8 +55,9 @@ module Formtastic #:nodoc:
     # columns all map to a single numeric_input, for example).
     #
     # * :select (a select menu for associations) - default to association names
+    # * :check_boxes (a set of check_box inputs for associations) - alternative to :select has_many and has_and_belongs_to_many associations
+    # * :radio (a set of radio inputs for associations) - alternative to :select belongs_to associations
     # * :time_zone (a select menu with time zones)
-    # * :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
@@ -65,6 +66,8 @@ module Formtastic #:nodoc:
     # * :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
+    # * :country (a select menu of country names) - requires a country_select plugin to be installed
+    # * :hidden (a hidden field) - creates a hidden field (added for compatibility)
     #
     # Example:
     #
@@ -78,7 +81,7 @@ module Formtastic #:nodoc:
     #   <% end %>
     #
     def input(method, options = {})
-      options[:required] = method_required?(method, options[:required])
+      options[:required] = method_required?(method) unless options.key?(:required)
       options[:as]     ||= default_input_type(method)
 
       html_class = [ options[:as], (options[:required] ? :required : :optional) ]
@@ -308,6 +311,65 @@ module Formtastic #:nodoc:
       fields_for(record_or_name_or_array, *args, &block)
     end
 
+    # Generates the label for the input. It also accepts the same arguments as
+    # Rails label method. It has three options that are not supported by Rails
+    # label method:
+    #
+    # * :required - Appends an abbr tag if :required is true
+    # * :label - An alternative form to give the label content. Whenever label
+    #            is false, a blank string is returned.
+    # * :as_span - When true returns a span tag with class label instead of a label element
+    #
+    # == Examples
+    #
+    #  f.label :title # like in rails, except that it searches the label on I18n API too
+    #
+    #  f.label :title, "Your post title"
+    #  f.label :title, :label => "Your post title" # Added for formtastic API
+    #
+    #  f.label :title, :required => true # Returns <label>Title<abbr title="required">*</abbr></label>
+    #
+    def label(method, options_or_text=nil, options=nil)
+      if options_or_text.is_a?(Hash)
+        return if options_or_text[:label] == false
+
+        options = options_or_text
+        text    = options.delete(:label)
+      else
+        text      = options_or_text
+        options ||= {}
+      end
+
+      text ||= humanized_attribute_name(method)
+      text  << required_or_optional_string(options.delete(:required))
+
+      if options.delete(:as_span)
+        options[:class] ||= 'label'
+        template.content_tag(:span, text, options)
+      else
+        super(method, text, options)
+      end
+    end
+
+    # Generates error messages for the given method. Errors can be shown as list
+    # or as sentence. If :none is set, no error is shown.
+    #
+    # This method is also aliased as errors_on, so you can call on your custom
+    # inputs as well:
+    #
+    #   semantic_form_for :post do |f|
+    #     f.text_field(:body)
+    #     f.errors_on(:body)
+    #   end
+    #
+    def inline_errors_for(method, options=nil) #:nodoc:
+      return nil unless @object && @object.respond_to?(:errors) && [:sentence, :list].include?(@@inline_errors)
+
+      errors = @object.errors.on(method.to_s)
+      send("error_#{@@inline_errors}", Array(errors)) unless errors.blank?
+    end
+    alias :errors_on :inline_errors_for
+
     #
     #  Stolen from Attribute_fu (http://github.com/giraffesoft/attribute_fu)
     #  Rails 2.3 Patches from http://github.com/odadata/attribute_fu
@@ -454,9 +516,7 @@ module Formtastic #:nodoc:
     # * 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?
-
+    def method_required?(attribute) #:nodoc:
       if @object && @object.class.respond_to?(:reflect_on_all_validations)
         attribute_sym = attribute.to_s.sub(/_id$/, '').to_sym
 
@@ -472,13 +532,24 @@ module Formtastic #:nodoc:
     # :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.
+    # If input_html is given as option, it's passed down to the input.  The :size option is
+    # also passed in since it's so common to want to customize it.
     #
     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)
+      html_options[:size] = options.delete(:size) if options.has_key?(:size)
+
+      self.label(method, options.slice(:label, :required)) +
+      self.send(INPUT_MAPPINGS[type], method, html_options)
+    end
 
-      input_label(method, options.delete(:label), options.slice(:required)) + send(INPUT_MAPPINGS[type], method, html_options)
+    # Outputs a hidden field inside the wrapper, which should be hidden with CSS.
+    # Additionals options can be given and will be sent straight to hidden input
+    # element.
+    #
+    def hidden_input(method, options)
+      self.hidden_field(method, set_options(options))
     end
 
     # Outputs a label and a select box containing options from the parent
@@ -570,7 +641,7 @@ module Formtastic #:nodoc:
        end
 
       input_name = generate_association_input_name(method)
-      input_label(input_name, options.delete(:label), options.slice(:required)) +
+      self.label(input_name, options.slice(:label, :required)) +
       self.select(input_name, collection, set_options(options), html_options)
     end
     alias :boolean_select_input :select_input
@@ -585,7 +656,7 @@ module Formtastic #:nodoc:
     def time_zone_input(method, options)
       html_options = options.delete(:input_html) || {}
 
-      input_label(method, options.delete(:label), options.slice(:required)) +
+      self.label(method, options.slice(:label, :required)) +
       self.time_zone_select(method, options.delete(:priority_zones), set_options(options), html_options)
     end
 
@@ -614,7 +685,7 @@ module Formtastic #:nodoc:
     # You can customize the options available in the set by passing in a collection (Array) of
     # ActiveRecord objects through the :collection option.  If not provided, the choices are found
     # by inferring the parent's class name from the method name and simply calling find(:all) on
-    # it (VehicleOwner.find(:all) in the example above).
+    # it (Author.find(:all) in the example above).
     #
     # Examples:
     #
@@ -732,6 +803,7 @@ module Formtastic #:nodoc:
       time_inputs << [:second] if options[:include_seconds]
 
       list_items_capture = ""
+      hidden_fields_capture = ""
 
       # Gets the datetime object. It can be a Fixnum, Date or Time, or nil.
       datetime     = @object ? @object.send(method) : nil
@@ -740,30 +812,137 @@ module Formtastic #:nodoc:
       (inputs + time_inputs).each do |input|
         html_id    = generate_html_id(method, "#{position[input]}i")
         field_name = "#{method}(#{position[input]}i)"
-
-        list_items_capture << if options["discard_#{input}".intern]
+        if options["discard_#{input}".intern]
           break if time_inputs.include?(input)
-
+          
           hidden_value = datetime.respond_to?(input) ? datetime.send(input) : datetime
-          template.hidden_field_tag("#{@object_name}[#{field_name}]", (hidden_value || 1), :id => html_id)
+          hidden_fields_capture << 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 => field_name)
           item_label_text = I18n.t(input.to_s, :default => input.to_s.humanize, :scope => [:datetime, :prompts])
 
-          template.content_tag(:li,
+          list_items_capture << template.content_tag(:li,
             template.content_tag(:label, item_label_text, :for => html_id) +
             template.send("select_#{input}".intern, datetime, opts, html_options.merge(:id => html_id))
           )
         end
       end
 
-      field_set_and_list_wrapping_for_method(method, options, list_items_capture)
+      hidden_fields_capture + field_set_and_list_wrapping_for_method(method, options, list_items_capture)
     end
 
+
+    # 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
+    # label and a check_box input.
+    #
+    # This is an alternative for has many and has and belongs to many associations.
+    #
+    # Example:
+    #
+    #   f.input :author, :as => :check_boxes
+    #
+    # Output:
+    #
+    #   <fieldset>
+    #     <legend><span>Authors</span></legend>
+    #     <ol>
+    #       <li>
+    #         <input type="hidden" name="book[author_id][1]" value="">
+    #         <label for="book_author_id_1"><input id="book_author_id_1" name="book[author_id][1]" type="checkbox" value="1" /> Justin French</label>
+    #       </li>
+    #       <li>
+    #         <input type="hidden" name="book[author_id][2]" value="">
+    #         <label for="book_author_id_2"><input id="book_author_id_2" name="book[owner_id][2]" type="checkbox" value="2" /> Kate French</label>
+    #       </li>
+    #     </ol>
+    #   </fieldset>
+    #
+    # Notice that the value of the checkbox is the same as the id and the hidden
+    # field has empty value. You can override the hidden field value using the
+    # unchecked_value option.
+    #
+    # You can customize the options available in the set by passing in a collection (Array) of
+    # ActiveRecord objects through the :collection option.  If not provided, the choices are found
+    # by inferring the parent's class name from the method name and simply calling find(:all) on
+    # it (Author.find(:all) in the example above).
+    #
+    # Examples:
+    #
+    #   f.input :author, :as => :check_boxes, :collection => @authors
+    #   f.input :author, :as => :check_boxes, :collection => Author.find(:all)
+    #   f.input :author, :as => :check_boxes, :collection => [@justin, @kate]
+    #
+    # You can also customize the text label inside each option tag, by naming the correct method
+    # (:full_name, :display_name, :account_number, etc) to call on each object in the collection
+    # by passing in the :label_method option.  By default the :label_method is whichever element of
+    # Formtastic::SemanticFormBuilder.collection_label_methods is found first.
+    #
+    # Examples:
+    #
+    #   f.input :author, :as => :check_boxes, :label_method => :full_name
+    #   f.input :author, :as => :check_boxes, :label_method => :display_name
+    #   f.input :author, :as => :check_boxes, :label_method => :to_s
+    #   f.input :author, :as => :check_boxes, :label_method => :label
+    #
+    # You can set :value_as_class => true if you want that LI wrappers contains
+    # a class with the wrapped checkbox input value.
+    #
+    def check_boxes_input(method, options)
+      collection = find_collection_for_column(method, options)
+      html_options = options.delete(:input_html) || {}
+
+      input_name      = generate_association_input_name(method)
+      value_as_class  = options.delete(:value_as_class)
+      unchecked_value = options.delete(:unchecked_value) || ''
+      html_options    = { :name => "#{@object_name}[#{input_name}][]" }.merge(html_options)
+
+      list_item_content = collection.map do |c|
+        label = c.is_a?(Array) ? c.first : c
+        value = c.is_a?(Array) ? c.last : c
+
+        html_options.merge!(:id => generate_html_id(input_name, value.to_s.downcase))
+ 
+        li_content = template.content_tag(:label,
+          "#{self.check_box(input_name, html_options, value, unchecked_value)} #{label}",
+          :for => html_options[:id]
+        )
+
+        li_options = value_as_class ? { :class => value.to_s.downcase } : {}
+        template.content_tag(:li, li_content, li_options)
+      end
+
+      field_set_and_list_wrapping_for_method(method, options, list_item_content)
+    end
+    
+    
+    # Outputs a country select input, wrapping around a regular country_select helper. 
+    # Rails doesn't come with a country_select helper by default any more, so you'll need to install
+    # the "official" plugin, or, if you wish, any other country_select plugin that behaves in the
+    # same way.
+    #
+    # The Rails plugin iso-3166-country-select plugin can be found "here":http://github.com/rails/iso-3166-country-select.
+    #
+    # By default, Formtastic includes a handfull of english-speaking countries as "priority counties", 
+    # which you can change to suit your market and user base (see README for more info on config).
+    #
+    # Examples:
+    #   f.input :location, :as => :country # use Formtastic::SemanticFormBuilder.priority_countries array for the priority countries
+    #   f.input :location, :as => :country, :priority_countries => /Australia/ # set your own
+    #
+    def country_input(method, options)
+      raise "To use the :country input, please install a country_select plugin, like this one: http://github.com/rails/iso-3166-country-select" unless self.respond_to?(:country_select)
+      
+      html_options = options.delete(:input_html) || {}
+      priority_countries = options.delete(:priority_countries) || @@priority_countries
+
+      self.label(method, options.slice(:label, :required)) +
+      self.country_select(method, priority_countries, set_options(options), html_options)
+    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.
-    #
-    # 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)
@@ -772,10 +951,8 @@ module Formtastic #:nodoc:
       input = self.check_box(method, set_options(options).merge(html_options),
                              options.delete(:checked_value) || '1', options.delete(:unchecked_value) || '0')
 
-      # Generate the label by hand because required or optional does not make sense here
       label = options.delete(:label) || humanized_attribute_name(method)
-
-      self.label(method, input + label, options)
+      self.label(method, input + label, options.slice(:required))
     end
 
     # Generates an input for the given method using the type supplied with :as.
@@ -795,31 +972,6 @@ module Formtastic #:nodoc:
       end
     end
 
-    # Generates error messages for the given method. Errors can be shown as list
-    # or as sentence. If :none is set, no error is shown.
-    #
-    def inline_errors_for(method, options)  #:nodoc:
-      return nil unless @object && @object.respond_to?(:errors) && [:sentence, :list].include?(@@inline_errors)
-
-      # Ruby 1.9: Strings are not Enumerable, ie no String#to_a
-      errors = @object.errors.on(method.to_s)
-      unless errors.respond_to?(:to_a)
-        errors = [errors]
-      else
-        errors = errors.to_a
-      end
-
-      # Ruby 1.9: Strings are not Enumerable, ie no String#to_a
-      errors = @object.errors.on(method.to_s)
-      unless errors.respond_to?(:to_a)
-        errors = [errors]
-      else
-        errors = errors.to_a
-      end
-
-      send("error_#{@@inline_errors}", errors) unless errors.empty?
-    end
-
     # Generates hints for the given method using the text supplied in :hint.
     #
     def inline_hints_for(method, options) #:nodoc:
@@ -830,7 +982,7 @@ module Formtastic #:nodoc:
     # 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')
+      template.content_tag(:p, errors.to_sentence.untaint, :class => 'inline-errors')
     end
 
     # Creates an error li list.
@@ -838,37 +990,28 @@ module Formtastic #:nodoc:
     def error_list(errors) #:nodoc:
       list_elements = []
       errors.each do |error|
-        list_elements <<  template.content_tag(:li, error)
+        list_elements <<  template.content_tag(:li, error.untaint)
       end
       template.content_tag(:ul, list_elements.join("\n"), :class => 'errors')
     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 ||= humanized_attribute_name(method)
-      text  << required_or_optional_string(options.delete(:required))
-
-      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
+      string_or_proc = case required
+        when true
+          @@required_string
+        when false
+          @@optional_string
+        else
+          required
+      end
 
-      if string_or_proc.is_a? Proc
+      if string_or_proc.is_a?(Proc)
         string_or_proc.call
       else
-        string_or_proc
+        string_or_proc.to_s
       end
     end
 
@@ -904,7 +1047,7 @@ module Formtastic #:nodoc:
     #
     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>} +
+        %{<legend>#{self.label(method, options.slice(:label, :required).merge!(:as_span => true))}</legend>} +
         template.content_tag(:ol, contents)
       )
     end
@@ -924,11 +1067,12 @@ module Formtastic #:nodoc:
 
       if column
         # handle the special cases where the column type doesn't map to an input method
-        return :time_zone if column.type == :string && method.to_s =~ /time_?zone/
+        return :time_zone if column.type == :string && method.to_s =~ /time_zone/
         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 :password  if column.type == :string && method.to_s =~ /password/
+        return :country   if column.type == :string && method.to_s =~ /country/
 
         # otherwise assume the input name will be the same as the column type (eg string_input)
         return column.type