justinfrench-formtastic 0.1.7 → 0.1.9

data/README.textile

@@ -227,6 +227,7 @@ Customize the HTML attributes for the @<li>@ wrapper around every input with the
 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
@@ -238,6 +239,9 @@ h2. The Available Inputs
 * :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.
 
@@ -284,6 +288,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>
 
 
@@ -313,6 +320,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
 
 
@@ -342,10 +350,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

@@ -59,7 +59,7 @@ 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; }
@@ -91,7 +91,12 @@ form.formtastic fieldset ol li.numeric input { width:74%; }
 form.formtastic fieldset ol li.text textarea { width:74%; }
 
 
-/* CHECKBOX OVERRIDES
+/* HIDDEN OVERRIDES
+--------------------------------------------------------------------------------------------------*/
+form.formtastic fieldset ol li.hidden { display:none; }
+
+
+/* BOOLEAN 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; }
@@ -106,6 +111,16 @@ form.formtastic fieldset ol li.radio fieldset ol li label { float:none; width:10
 form.formtastic fieldset ol li.radio fieldset ol li label input { margin-right:0.2em; }
 
 
+/* 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 ol li,

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:
     #
@@ -308,18 +311,39 @@ module Formtastic #:nodoc:
       fields_for(record_or_name_or_array, *args, &block)
     end
 
-    # Generates the label for the input. Accepts the same arguments as Rails
-    # label method and a fourth one that allows the label to be generated
-    # as span tag with class label.
+    # 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
     #
-    # :required can be also sent as option. When true, marks a filed as required,
-    # when false marks it as optional. When nil, does nothing.
+    #  f.label :title, "Your post title"
+    #  f.label :title, :label => "Your post title" # Added for formtastic API
     #
-    def label(method, text=nil, options={}, as_span=false)
+    #  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 as_span
+      if options.delete(:as_span)
         options[:class] ||= 'label'
         template.content_tag(:span, text, options)
       else
@@ -327,6 +351,25 @@ 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.
+    #
+    # 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
+
     protected
 
     # Deals with :for option when it's supplied to inputs methods. Additional
@@ -410,10 +453,18 @@ module Formtastic #:nodoc:
       html_options = options.delete(:input_html) || {}
       html_options = default_string_options(method).merge(html_options) if STRING_MAPPINGS.include?(type)
 
-      self.label(method, options.delete(:label), options.slice(:required)) +
+      self.label(method, options.slice(:label, :required)) +
       self.send(INPUT_MAPPINGS[type], method, html_options)
     end
 
+    # 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
     # (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
@@ -503,7 +554,7 @@ module Formtastic #:nodoc:
        end
 
       input_name = generate_association_input_name(method)
-      self.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
@@ -518,7 +569,7 @@ module Formtastic #:nodoc:
     def time_zone_input(method, options)
       html_options = options.delete(:input_html) || {}
 
-      self.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
 
@@ -547,7 +598,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:
     #
@@ -665,6 +716,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
@@ -673,26 +725,135 @@ 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.
     # :checked_value and :unchecked_value options are also available.
@@ -724,23 +885,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
-
-      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:
@@ -816,7 +960,7 @@ module Formtastic #:nodoc:
     #
     def field_set_and_list_wrapping_for_method(method, options, contents)
       template.content_tag(:fieldset,
-        %{<legend>#{self.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
@@ -841,6 +985,7 @@ module Formtastic #:nodoc:
         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

data/spec/formtastic_spec.rb

@@ -234,6 +234,10 @@ describe 'Formtastic' do
         @new_post.stub!(:body)
         @new_post.stub!(:column_for_attribute).and_return(mock('column', :type => :string, :limit => 255))
       end
+      
+      after do
+        Formtastic::SemanticFormHelper.builder = Formtastic::SemanticFormBuilder
+      end
 
       it "can be overridden" do
 
@@ -293,15 +297,92 @@ describe 'Formtastic' do
         end
       end
 
-      it 'should append required note' do
+      it 'should be printed as span' do
         semantic_form_for(@new_post) do |builder|
-          builder.label(:login, nil, :required => true).should have_tag('label abbr')
+          builder.label(:login, nil, { :required => true, :as_span => true }).should have_tag('span.label abbr')
         end
       end
 
-      it 'should be printed as span' do
-        semantic_form_for(@new_post) do |builder|
-          builder.label(:login, nil, { :required => true }, true).should have_tag('span.label abbr')
+      describe 'when required is given' do
+        it 'should append a required note' do
+          semantic_form_for(@new_post) do |builder|
+            builder.label(:login, nil, :required => true).should have_tag('label abbr')
+          end
+        end
+
+        it 'should allow require option to be given as second argument' do
+          semantic_form_for(@new_post) do |builder|
+            builder.label(:login, :required => true).should have_tag('label abbr')
+          end
+        end
+      end
+
+      describe 'when label is given' do
+        it 'should allow the text to be given as label option' do
+          semantic_form_for(@new_post) do |builder|
+            builder.label(:login, :required => true, :label => 'My label').should have_tag('label', :with => /My label/)
+          end
+        end
+
+        it 'should return nil if label is false' do
+          semantic_form_for(@new_post) do |builder|
+            builder.label(:login, :label => false).should be_nil
+          end
+        end
+      end
+    end
+
+    describe '#errors_on' do
+      before(:each) do
+        @title_errors = ['must not be blank', 'must be longer than 10 characters', 'must be awesome']
+        @errors = mock('errors')
+        @errors.stub!(:on).with('title').and_return(@title_errors)
+        @errors.stub!(:on).with('body').and_return(nil)
+        @new_post.stub!(:errors).and_return(@errors)
+      end
+
+      describe 'and the errors will be displayed as a sentence' do
+        it 'should render a paragraph with the errors joined into a sentence' do
+          Formtastic::SemanticFormBuilder.inline_errors = :sentence
+          semantic_form_for(@new_post) do |builder|
+            builder.errors_on(:title).should have_tag('p.inline-errors', @title_errors.to_sentence)
+          end
+        end
+      end
+
+      describe 'and the errors will be displayed as a list' do
+        it 'should render an unordered list with the class errors' do
+          Formtastic::SemanticFormBuilder.inline_errors = :list
+          semantic_form_for(@new_post) do |builder|
+            builder.errors_on(:title).should have_tag('ul.errors')
+          end
+        end
+
+        it 'should include a list element for each of the errors within the unordered list' do
+          Formtastic::SemanticFormBuilder.inline_errors = :list
+          semantic_form_for(@new_post) do |builder|
+            @title_errors.each do |error|
+              builder.errors_on(:title).should have_tag('ul.errors li', error)
+            end
+          end
+        end
+      end
+
+      describe 'but the errors will not be shown' do
+        it 'should return nil' do
+          Formtastic::SemanticFormBuilder.inline_errors = :none
+          semantic_form_for(@new_post) do |builder|
+            builder.errors_on(:title).should be_nil
+          end
+        end
+      end
+
+      describe 'and no error is found on the method' do
+        it 'should return nil' do
+          Formtastic::SemanticFormBuilder.inline_errors = :sentence
+          semantic_form_for(@new_post) do |builder|
+            builder.errors_on(:body).should be_nil
+          end
         end
       end
     end
@@ -558,6 +639,10 @@ describe 'Formtastic' do
               default_input_type(:float).should == :numeric
               default_input_type(:decimal).should == :numeric
             end
+            
+            it 'should default to :country for :string columns named country' do
+              default_input_type(:string, :country).should == :country
+            end
 
             describe 'defaulting to file column' do
               Formtastic::SemanticFormBuilder.file_methods.each do |method|
@@ -581,7 +666,7 @@ describe 'Formtastic' do
           end
 
           it 'should call the corresponding input method' do
-            [:select, :time_zone, :radio, :date, :datetime, :time, :boolean].each do |input_style|
+            [:select, :time_zone, :radio, :date, :datetime, :time, :boolean, :check_boxes, :hidden].each do |input_style|
               @new_post.stub!(:generic_column_name)
               @new_post.stub!(:column_for_attribute).and_return(mock('column', :type => :string, :limit => 255))
               semantic_form_for(@new_post) do |builder|
@@ -721,7 +806,6 @@ describe 'Formtastic' do
         end
 
         describe 'when there are errors on the object for this method' do
-
           before do
             @title_errors = ['must not be blank', 'must be longer than 10 characters', 'must be awesome']
             @errors = mock('errors')
@@ -743,65 +827,24 @@ describe 'Formtastic' do
             output_buffer.should_not have_tag('div.fieldWithErrors')
           end
 
-          describe 'and the errors will be displayed as a sentence' do
-
-            before do
-              Formtastic::SemanticFormBuilder.inline_errors = :sentence
-              semantic_form_for(@new_post) do |builder|
-                concat(builder.input(:title))
-              end
-            end
-
-            it 'should render a paragraph with the errors joined into a sentence' do
-              output_buffer.should have_tag('form li.error p.inline-errors', @title_errors.to_sentence)
-            end
-
-          end
-
-          describe 'and the errors will be displayed as a list' do
-
-            before do
-              Formtastic::SemanticFormBuilder.inline_errors = :list
-              semantic_form_for(@new_post) do |builder|
-                concat(builder.input(:title))
-              end
-            end
-
-            it 'should render an unordered list with the class errors' do
-              output_buffer.should have_tag('form li.error ul.errors')
-            end
-
-            it 'should include a list element for each of the errors within the unordered list' do
-              @title_errors.each do |error|
-                output_buffer.should have_tag('form li.error ul.errors li', error)
-              end
+          it 'should render a paragraph for the errors' do
+            Formtastic::SemanticFormBuilder.inline_errors = :sentence
+            semantic_form_for(@new_post) do |builder|
+              concat(builder.input(:title))
             end
-
+            output_buffer.should have_tag('form li.error p.inline-errors')
           end
 
-          describe 'but the errors will not be shown' do
-
-            before do
-              Formtastic::SemanticFormBuilder.inline_errors = :none
-              semantic_form_for(@new_post) do |builder|
-                concat(builder.input(:title))
-              end
-            end
-
-            it 'should not display an error sentence' do
-              output_buffer.should_not have_tag('form li.error p.inline-errors')
-            end
-
-            it 'should not display an error list' do
-              output_buffer.should_not have_tag('form li.error ul.errors')
+          it 'should not display an error list' do
+            Formtastic::SemanticFormBuilder.inline_errors = :list
+            semantic_form_for(@new_post) do |builder|
+              concat(builder.input(:title))
             end
-
+            output_buffer.should have_tag('form li.error ul.errors')
           end
-
         end
 
         describe 'when there are no errors on the object for this method' do
-
           before do
             semantic_form_for(@new_post) do |builder|
               concat(builder.input(:title))
@@ -819,11 +862,9 @@ describe 'Formtastic' do
           it 'should not display an error list' do
             output_buffer.should_not have_tag('form li.error ul.errors')
           end
-
         end
 
         describe 'when no object is provided' do
-
           before do
             semantic_form_for(:project, :url => 'http://test.host') do |builder|
               concat(builder.input(:title))
@@ -841,7 +882,6 @@ describe 'Formtastic' do
           it 'should not display an error list' do
             output_buffer.should_not have_tag('form li.error ul.errors')
           end
-
         end
       end
 
@@ -1008,30 +1048,65 @@ describe 'Formtastic' do
 
           end
 
-          it 'should generate input and labels even if no object is given' do
-            semantic_form_for(:project, :url => 'http://test.host/') do |builder|
-              concat(builder.input(:title, :as => type))
+          describe 'when no object is given' do
+            before(:each) do
+              semantic_form_for(:project, :url => 'http://test.host/') do |builder|
+                concat(builder.input(:title, :as => type))
+              end
             end
 
-            output_buffer.should have_tag('form li label')
-            output_buffer.should have_tag('form li label[@for="project_title"')
-            output_buffer.should have_tag('form li label', /Title/)
+            it 'should generate input' do
+              if template_method.to_s =~ /_field$/ # password_field
+                output_buffer.should have_tag("form li input")
+                output_buffer.should have_tag("form li input#project_title")
+                output_buffer.should have_tag("form li input[@type=\"#{input_type}\"]")
+                output_buffer.should have_tag("form li input[@name=\"project[title]\"]")
+              else
+                output_buffer.should have_tag("form li #{input_type}")
+                output_buffer.should have_tag("form li #{input_type}#project_title")
+                output_buffer.should have_tag("form li #{input_type}[@name=\"project[title]\"]")
+              end
+            end
 
-            if template_method.to_s =~ /_field$/ # password_field
-              output_buffer.should have_tag("form li input")
-              output_buffer.should have_tag("form li input#project_title")
-              output_buffer.should have_tag("form li input[@type=\"#{input_type}\"]")
-              output_buffer.should have_tag("form li input[@name=\"project[title]\"]")
-            else
-              output_buffer.should have_tag("form li #{input_type}")
-              output_buffer.should have_tag("form li #{input_type}#project_title")
-              output_buffer.should have_tag("form li #{input_type}[@name=\"project[title]\"]")
+            it 'should generate labels' do
+              output_buffer.should have_tag('form li label')
+              output_buffer.should have_tag('form li label[@for="project_title"')
+              output_buffer.should have_tag('form li label', /Title/)
             end
           end
 
         end
       end
 
+      describe ":as => :hidden" do
+        before do
+          @new_post.stub!(:hidden)
+          @new_post.stub!(:column_for_attribute).and_return(mock('column', :type => :string))
+
+          semantic_form_for(@new_post) do |builder|
+            concat(builder.input(:hidden, :as => :hidden))
+          end
+        end
+
+        it "should have a hidden class on the wrapper" do
+          output_buffer.should have_tag('form li.hidden')
+        end
+
+        it 'should have a post_hidden_input id on the wrapper' do
+          output_buffer.should have_tag('form li#post_hidden_input')
+        end
+
+        it 'should not generate a label for the input' do
+          output_buffer.should_not have_tag('form li label')
+        end
+
+        it "should generate a input field" do
+          output_buffer.should have_tag("form li input#post_hidden")
+          output_buffer.should have_tag("form li input[@type=\"hidden\"]")
+          output_buffer.should have_tag("form li input[@name=\"post[hidden]\"]")
+        end
+      end
+
       describe ":as => :time_zone" do
         before do
           @new_post.stub!(:time_zone)
@@ -1069,27 +1144,110 @@ describe 'Formtastic' do
           output_buffer.should have_tag("form li select.myclass")
         end
 
-        it 'should generate input and labels even if no object is given' do
-          semantic_form_for(:project, :url => 'http://test.host/') do |builder|
-            concat(builder.input(:time_zone, :as => :time_zone))
+        describe 'when no object is given' do
+          before(:each) do
+            semantic_form_for(:project, :url => 'http://test.host/') do |builder|
+              concat(builder.input(:time_zone, :as => :time_zone))
+            end
           end
 
-          output_buffer.should have_tag('form li label')
-          output_buffer.should have_tag('form li label[@for="project_time_zone"')
-          output_buffer.should have_tag('form li label', /Time zone/)
+          it 'should generate labels' do
+            output_buffer.should have_tag('form li label')
+            output_buffer.should have_tag('form li label[@for="project_time_zone"')
+            output_buffer.should have_tag('form li label', /Time zone/)
+          end
 
-          output_buffer.should have_tag("form li select")
-          output_buffer.should have_tag("form li select#project_time_zone")
-          output_buffer.should have_tag("form li select[@name=\"project[time_zone]\"]")
+          it 'should generate select inputs' do
+            output_buffer.should have_tag("form li select")
+            output_buffer.should have_tag("form li select#project_time_zone")
+            output_buffer.should have_tag("form li select[@name=\"project[time_zone]\"]")
+          end
         end
       end
+      
+      describe ":as => :country" do
+        
+        before do
+          @new_post.stub!(:country)
+          @new_post.stub!(:column_for_attribute).and_return(mock('column', :type => :string))
+        end
+        
+        describe "when country_select is not available as a helper from a plugin" do
+          
+          it "should raise an error, sugesting the author installs a plugin" do
+            lambda { 
+              semantic_form_for(@new_post) do |builder|
+                concat(builder.input(:country, :as => :country))
+              end
+            }.should raise_error  
+          end
+          
+        end
+        
+        describe "when country_select is available as a helper (from a plugin)" do
+          
+          before do
+            semantic_form_for(@new_post) do |builder|
+              builder.stub!(:country_select).and_return("<select><option>...</option></select>")
+              concat(builder.input(:country, :as => :country))
+            end
+          end
+          
+          it "should have a time_zone class on the wrapper" do
+            output_buffer.should have_tag('form li.country')
+          end
+
+          it 'should have a post_title_input id on the wrapper' do
+            output_buffer.should have_tag('form li#post_country_input')
+          end
+
+          it 'should generate a label for the input' do
+            output_buffer.should have_tag('form li label')
+            output_buffer.should have_tag('form li label[@for="post_country"')
+            output_buffer.should have_tag('form li label', /Country/)
+          end
 
+          it "should generate a select" do
+            output_buffer.should have_tag("form li select")
+          end
+          
+        end
+        
+        describe ":priority_countries option" do
+            
+          it "should be passed down to the country_select helper when provided" do
+            priority_countries = ["Foo", "Bah"]
+            semantic_form_for(@new_post) do |builder|
+              builder.stub!(:country_select).and_return("<select><option>...</option></select>")
+              builder.should_receive(:country_select).with(:country, priority_countries, {}, {}).and_return("<select><option>...</option></select>")
+              
+              concat(builder.input(:country, :as => :country, :priority_countries => priority_countries))
+            end
+          end
+            
+          it "should default to the @@priority_countries config when absent" do 
+            priority_countries = Formtastic::SemanticFormBuilder.priority_countries
+            priority_countries.should_not be_empty
+            priority_countries.should_not be_nil
+            
+            semantic_form_for(@new_post) do |builder|
+              builder.stub!(:country_select).and_return("<select><option>...</option></select>")
+              builder.should_receive(:country_select).with(:country, priority_countries, {}, {}).and_return("<select><option>...</option></select>")
+              
+              concat(builder.input(:country, :as => :country))
+            end
+          end
+          
+        end
+        
+      end
+      
       describe ':as => :radio' do
 
         before do
           @new_post.stub!(:author).and_return(@bob)
           @new_post.stub!(:author_id).and_return(@bob.id)
-          @new_post.stub!(:column_for_attribute).and_return(mock('column', :type => :integer, :limit => 255))
+          Post.stub!(:reflect_on_association).and_return { |column_name| mock('reflection', :klass => Author, :macro => :belongs_to) }
         end
 
         describe 'for belongs_to association' do
@@ -1103,7 +1261,7 @@ describe 'Formtastic' do
             output_buffer.should have_tag('form li.radio')
           end
 
-          it 'should have a post_author_id_input id on the wrapper' do
+          it 'should have a post_author_input id on the wrapper' do
             output_buffer.should have_tag('form li#post_author_input')
           end
 
@@ -1118,7 +1276,7 @@ describe 'Formtastic' do
             output_buffer.should have_tag('form li fieldset ol li', :count => Author.find(:all).size)
           end
 
-          it 'should have one option with a "selected" attribute' do
+          it 'should have one option with a "checked" attribute' do
             output_buffer.should have_tag('form li input[@checked]', :count => 1)
           end
 
@@ -1126,10 +1284,8 @@ describe 'Formtastic' do
 
             it 'should contain a label for the radio input with a nested input and label text' do
               Author.find(:all).each do |author|
-                output_buffer.should have_tag('form li fieldset ol li label')
                 output_buffer.should have_tag('form li fieldset ol li label', /#{author.to_label}/)
                 output_buffer.should have_tag("form li fieldset ol li label[@for='post_author_id_#{author.id}']")
-                output_buffer.should have_tag("form li fieldset ol li label input")
               end
             end
 
@@ -1161,29 +1317,39 @@ describe 'Formtastic' do
             end
           end
 
-          it 'should generate a fieldset, legend, labels and inputs even if no object is given' do
-            output_buffer.replace ''
+          describe 'and no object is given' do
+            before(:each) do
+              output_buffer.replace ''
+              semantic_form_for(:project, :url => 'http://test.host') do |builder|
+                concat(builder.input(:author_id, :as => :radio, :collection => Author.find(:all)))
+              end
+            end
 
-            semantic_form_for(:project, :url => 'http://test.host') do |builder|
-              concat(builder.input(:author_id, :as => :radio, :collection => Author.find(:all)))
+            it 'should generate a fieldset with legend' do
+              output_buffer.should have_tag('form li fieldset legend', /Author/)
             end
 
-            output_buffer.should have_tag('form li fieldset legend', /Author/)
-            output_buffer.should have_tag('form li fieldset ol li', :count => Author.find(:all).size)
+            it 'shold generate an li tag for each item in the collection' do
+              output_buffer.should have_tag('form li fieldset ol li', :count => Author.find(:all).size)
+            end
 
-            Author.find(:all).each do |author|
-              output_buffer.should have_tag('form li fieldset ol li label', /#{author.to_label}/)
-              output_buffer.should have_tag("form li fieldset ol li label[@for='project_author_id_#{author.id}']")
+            it 'should generate labels for each item' do
+              Author.find(:all).each do |author|
+                output_buffer.should have_tag('form li fieldset ol li label', /#{author.to_label}/)
+                output_buffer.should have_tag("form li fieldset ol li label[@for='project_author_id_#{author.id}']")
+              end
+            end
 
-              output_buffer.should have_tag("form li fieldset ol li label input#project_author_id_#{author.id}")
-              output_buffer.should have_tag("form li fieldset ol li label input[@type='radio']")
-              output_buffer.should have_tag("form li fieldset ol li label input[@value='#{author.id}']")
-              output_buffer.should have_tag("form li fieldset ol li label input[@name='project[author_id]']")
+            it 'should generate inputs for each item' do
+              Author.find(:all).each do |author|
+                output_buffer.should have_tag("form li fieldset ol li label input#project_author_id_#{author.id}")
+                output_buffer.should have_tag("form li fieldset ol li label input[@type='radio']")
+                output_buffer.should have_tag("form li fieldset ol li label input[@value='#{author.id}']")
+                output_buffer.should have_tag("form li fieldset ol li label input[@name='project[author_id]']")
+              end
             end
           end
-
         end
-
       end
 
       describe ':as => :select' do
@@ -1341,19 +1507,126 @@ describe 'Formtastic' do
           end
         end
 
-        it 'should generate label, select and options even if object is not given' do
-          semantic_form_for(:project, :url => 'http://test.host') do |builder|
-            concat(builder.input(:author, :as => :select, :collection => Author.find(:all)))
+        describe 'when no object is given' do
+          before(:each) do
+            semantic_form_for(:project, :url => 'http://test.host') do |builder|
+              concat(builder.input(:author, :as => :select, :collection => Author.find(:all)))
+            end
           end
 
-          output_buffer.should have_tag('form li label', /Author/)
-          output_buffer.should have_tag("form li label[@for='project_author']")
+          it 'should generate label' do
+            output_buffer.should have_tag('form li label', /Author/)
+            output_buffer.should have_tag("form li label[@for='project_author']")
+          end
 
-          output_buffer.should have_tag('form li select#project_author')
-          output_buffer.should have_tag('form li select option', :count => Author.find(:all).size)
+          it 'should generate select inputs' do
+            output_buffer.should have_tag('form li select#project_author')
+            output_buffer.should have_tag('form li select option', :count => Author.find(:all).size)
+          end
 
-          Author.find(:all).each do |author|
-            output_buffer.should have_tag("form li select option[@value='#{author.id}']", /#{author.to_label}/)
+          it 'should generate an option to each item' do
+            Author.find(:all).each do |author|
+              output_buffer.should have_tag("form li select option[@value='#{author.id}']", /#{author.to_label}/)
+            end
+          end
+        end
+      end
+
+      describe ':as => :check_boxes' do
+
+        describe 'for a has_many association' do
+          before do
+            semantic_form_for(@fred) do |builder|
+              concat(builder.input(:posts, :as => :check_boxes, :value_as_class => true))
+            end
+          end
+
+          it 'should have a check_boxes class on the wrapper' do
+            output_buffer.should have_tag('form li.check_boxes')
+          end
+
+          it 'should have a author_posts_input id on the wrapper' do
+            output_buffer.should have_tag('form li#author_posts_input')
+          end
+
+          it 'should generate a fieldset and legend containing label text for the input' do
+            output_buffer.should have_tag('form li fieldset')
+            output_buffer.should have_tag('form li fieldset legend')
+            output_buffer.should have_tag('form li fieldset legend', /Posts/)
+          end
+
+          it 'should generate an ordered list with a list item for each choice' do
+            output_buffer.should have_tag('form li fieldset ol')
+            output_buffer.should have_tag('form li fieldset ol li', :count => Post.find(:all).size)
+          end
+
+          it 'should have one option with a "checked" attribute' do
+            output_buffer.should have_tag('form li input[@checked]', :count => 1)
+          end
+
+          it 'should generate hidden inputs with default value blank' do
+            output_buffer.should have_tag("form li fieldset ol li label input[@type='hidden'][@value='']", :count => Post.find(:all).size)
+          end
+
+          describe "each choice" do
+
+            it 'should contain a label for the radio input with a nested input and label text' do
+              Post.find(:all).each do |post|
+                output_buffer.should have_tag('form li fieldset ol li label', /#{post.to_label}/)
+                output_buffer.should have_tag("form li fieldset ol li label[@for='author_post_ids_#{post.id}']")
+              end
+            end
+
+            it 'should use values as li.class when value_as_class is true' do
+              Post.find(:all).each do |post|
+                output_buffer.should have_tag("form li fieldset ol li.#{post.id} label")
+              end
+            end
+
+            it 'should have a checkbox input for each post' do
+              Post.find(:all).each do |post|
+                output_buffer.should have_tag("form li fieldset ol li label input#author_post_ids_#{post.id}")
+                output_buffer.should have_tag("form li fieldset ol li label input[@name='author[post_ids][]']", :count => 2)
+              end
+            end
+
+            it "should mark input as checked if it's the the existing choice" do
+              Post.find(:all).include?(@fred.posts.first).should be_true
+              output_buffer.should have_tag("form li fieldset ol li label input[@checked='checked']")
+            end
+          end
+
+          describe 'and no object is given' do
+            before(:each) do
+              output_buffer.replace ''
+              semantic_form_for(:project, :url => 'http://test.host') do |builder|
+                concat(builder.input(:author_id, :as => :check_boxes, :collection => Author.find(:all)))
+              end
+            end
+
+            it 'should generate a fieldset with legend' do
+              output_buffer.should have_tag('form li fieldset legend', /Author/)
+            end
+
+            it 'shold generate an li tag for each item in the collection' do
+              output_buffer.should have_tag('form li fieldset ol li', :count => Author.find(:all).size)
+            end
+
+            it 'should generate labels for each item' do
+              Author.find(:all).each do |author|
+                output_buffer.should have_tag('form li fieldset ol li label', /#{author.to_label}/)
+                output_buffer.should have_tag("form li fieldset ol li label[@for='project_author_id_#{author.id}']")
+              end
+            end
+
+            it 'should generate inputs for each item' do
+              Author.find(:all).each do |author|
+                output_buffer.should have_tag("form li fieldset ol li label input#project_author_id_#{author.id}")
+                output_buffer.should have_tag("form li fieldset ol li label input[@type='checkbox']")
+                output_buffer.should have_tag("form li fieldset ol li label input[@value='#{author.id}']")
+                output_buffer.should have_tag("form li fieldset ol li label input[@name='project[author_id][]']")
+              end
+            end
           end
         end
       end
@@ -1366,7 +1639,7 @@ describe 'Formtastic' do
           @new_post.stub!(:column_for_attribute).and_return(mock('column', :type => :integer, :limit => 255))
         end
 
-        { :select => :option, :radio => :input }.each do |type, countable|
+        { :select => :option, :radio => :input, :check_boxes => :'input[@type="checkbox"]' }.each do |type, countable|
 
           describe ":as => #{type.inspect}" do
             describe 'when the :collection option is not provided' do
@@ -1421,9 +1694,9 @@ describe 'Formtastic' do
                     concat(builder.input(:category_name, :as => type, :collection => @categories))
                   end
 
-                  @categories.each do |item|
-                    output_buffer.should have_tag("form li.#{type}", /#{item}/)
-                    output_buffer.should have_tag("form li.#{type} #{countable}[@value=#{item}]")
+                  @categories.each do |value|
+                    output_buffer.should have_tag("form li.#{type}", /#{value}/)
+                    output_buffer.should have_tag("form li.#{type} #{countable}[@value='#{value}']")
                   end
                 end
 
@@ -1456,7 +1729,7 @@ describe 'Formtastic' do
 
                   @categories.each do |label, value|
                     output_buffer.should have_tag("form li.#{type}", /#{label}/)
-                    output_buffer.should have_tag("form li.#{type} #{countable}[@value=#{value}]")
+                    output_buffer.should have_tag("form li.#{type} #{countable}[@value='#{value}']")
                   end
                 end
               end
@@ -1469,12 +1742,13 @@ describe 'Formtastic' do
 
                 it "should use the first value as the label text and the last value as the value attribute for #{countable}" do
                   semantic_form_for(@new_post) do |builder|
-                    concat(builder.input(:category_name, :as => :radio, :collection => @categories))
+                    concat(builder.input(:category_name, :as => type, :collection => @categories))
                   end
 
-                  @categories.each do |label, value|
-                    output_buffer.should have_tag('form li fieldset ol li label', /#{label}/i)
-                    output_buffer.should have_tag('form li fieldset ol li label input[@value='+value+']')
+                  @categories.each do |text, value|
+                    label = type == :select ? :option : :label
+                    output_buffer.should have_tag("form li.#{type} #{label}", /#{text}/i)
+                    output_buffer.should have_tag("form li.#{type} #{countable}[@value='#{value.to_s}']")
                   end
                 end
               end
@@ -1487,12 +1761,13 @@ describe 'Formtastic' do
 
                 it "should use the symbol as the label text and value for each #{countable}" do
                   semantic_form_for(@new_post) do |builder|
-                    concat(builder.input(:category_name, :as => :radio, :collection => @categories))
+                    concat(builder.input(:category_name, :as => type, :collection => @categories))
                   end
 
                   @categories.each do |value|
-                    output_buffer.should have_tag('form li fieldset ol li label', /#{value}/i)
-                    output_buffer.should have_tag('form li fieldset ol li label input[@value='+value.to_s+']')
+                    label = type == :select ? :option : :label
+                    output_buffer.should have_tag("form li.#{type} #{label}", /#{value}/i)
+                    output_buffer.should have_tag("form li.#{type} #{countable}[@value='#{value.to_s}']")
                   end
                 end
               end
@@ -1549,8 +1824,15 @@ describe 'Formtastic' do
               end
 
             end
+          end
+        end
+
+        describe 'for boolean attributes' do
 
-            describe 'when attribute is a boolean' do
+          { :select => :option, :radio => :input }.each do |type, countable|
+            checked_or_selected = { :select => :selected, :radio => :checked }[type]
+
+            describe ":as => #{type.inspect}" do
 
               before do
                 @new_post.stub!(:allow_comments)
@@ -1598,8 +1880,6 @@ describe 'Formtastic' do
                 end
               end
 
-              checked_or_selected = { :select => :selected, :radio => :checked }[type]
-
               describe 'when the value is nil' do
                 before do
                   @new_post.stub!(:allow_comments).and_return(nil)
@@ -1667,7 +1947,6 @@ describe 'Formtastic' do
               end
             end
 
-
           end
         end
       end
@@ -1775,7 +2054,7 @@ describe 'Formtastic' do
               concat(builder.input(:publish_at, :as => :datetime, :discard_day => true))
             end
 
-            output_buffer.should have_tag("form li fieldset ol input[@type='hidden'][@value='1']")
+            output_buffer.should have_tag("form li input[@type='hidden'][@value='1']")
           end
 
           it 'should use default attribute value when it is not nil' do
@@ -1784,7 +2063,7 @@ describe 'Formtastic' do
               concat(builder.input(:publish_at, :as => :datetime, :discard_day => true))
             end
 
-            output_buffer.should have_tag("form li fieldset ol input[@type='hidden'][@value='27']")
+            output_buffer.should have_tag("form li input[@type='hidden'][@value='27']")
           end
         end
 
@@ -1857,16 +2136,25 @@ describe 'Formtastic' do
           end
         end
 
-        it 'should have fieldset, legend, label and selects even if object is not given' do
-          output_buffer.replace ''
+        describe 'when no object is given' do
+          before(:each) do
+            output_buffer.replace ''
+            semantic_form_for(:project, :url => 'http://test.host') do |@builder|
+              concat(@builder.input(:publish_at, :as => :datetime))
+            end
+          end
 
-          semantic_form_for(:project, :url => 'http://test.host') do |@builder|
-            concat(@builder.input(:publish_at, :as => :datetime))
+          it 'should have fieldset with legend' do
+            output_buffer.should have_tag('form li.datetime fieldset legend', /Publish at/)
           end
 
-          output_buffer.should have_tag('form li.datetime fieldset legend', /Publish at/)
-          output_buffer.should have_tag('form li.datetime fieldset ol li label', :count => 5)
-          output_buffer.should have_tag('form li.datetime fieldset ol li select', :count => 5)
+          it 'should have labels for each input' do
+            output_buffer.should have_tag('form li.datetime fieldset ol li label', :count => 5)
+          end
+
+          it 'should have selects for each inputs' do
+            output_buffer.should have_tag('form li.datetime fieldset ol li select', :count => 5)
+          end
         end
       end
 
@@ -1903,8 +2191,9 @@ describe 'Formtastic' do
           output_buffer.should have_tag('form li.time fieldset ol li label', /minute/i)
         end
 
-        it 'should have five selects for hour and minute' do
-          output_buffer.should have_tag('form li.time fieldset ol li select', :count => 2)
+        it 'should have two selects for hour and minute' do
+          #output_buffer.should have_tag('form li.time fieldset ol li select', :count => 2)
+          output_buffer.should have_tag('form li.time fieldset ol li', :count => 2)
         end
       end
 
@@ -1983,7 +2272,6 @@ describe 'Formtastic' do
       end
     end
 
-
     describe '#inputs' do
 
       describe 'with a block' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: justinfrench-formtastic
 version: !ruby/object:Gem::Version 
-  version: 0.1.7
+  version: 0.1.9
 platform: ruby
 authors: 
 - Justin French
@@ -9,7 +9,7 @@ autorequire: formtastic
 bindir: bin
 cert_chain: []
 
-date: 2009-04-22 00:00:00 -07:00
+date: 2009-05-21 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -25,24 +25,19 @@ files:
 - MIT-LICENSE
 - README.textile
 - Rakefile
-- rails/init.rb
-- lib/formtastic.rb
-- lib/justin_french
-- lib/justin_french/formtastic.rb
-- lib/locale
-- lib/locale/en.yml
-- generators/formtastic_stylesheets
 - generators/formtastic_stylesheets/formtastic_stylesheets_generator.rb
-- generators/formtastic_stylesheets/templates
 - generators/formtastic_stylesheets/templates/formtastic.css
 - generators/formtastic_stylesheets/templates/formtastic_changes.css
+- lib/formtastic.rb
+- lib/justin_french/formtastic.rb
+- lib/locale/en.yml
+- rails/init.rb
 - spec/formtastic_spec.rb
 - spec/test_helper.rb
-has_rdoc: true
+has_rdoc: false
 homepage: http://github.com/justinfrench/formtastic/tree/master
 post_install_message: 
 rdoc_options: 
-- --inline-source
 - --charset=UTF-8
 require_paths: 
 - lib
@@ -63,7 +58,8 @@ requirements: []
 rubyforge_project: 
 rubygems_version: 1.2.0
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: A Rails form builder plugin/gem with semantically rich and accessible markup
-test_files: []
-
+test_files: 
+- spec/formtastic_spec.rb
+- spec/test_helper.rb