formtastic 2.0.0.rc3 → 2.0.0.rc4

data/lib/formtastic/inputs/check_boxes_input.rb

@@ -127,7 +127,7 @@ module Formtastic
         value = choice_value(choice)
         builder.check_box(
           association_primary_key || method, 
-          input_html_options.merge(:id => choice_input_dom_id(choice), :name => input_name, :disabled => disabled?(value)), 
+          input_html_options.merge(:id => choice_input_dom_id(choice), :name => input_name, :disabled => disabled?(value), :required => false), 
           value, 
           unchecked_value
         )
@@ -139,7 +139,7 @@ module Formtastic
           input_name, 
           value, 
           checked?(value), 
-          input_html_options.merge(:id => choice_input_dom_id(choice), :disabled => disabled?(value))
+          input_html_options.merge(:id => choice_input_dom_id(choice), :disabled => disabled?(value), :required => false)
         ) 
       end
       
@@ -154,7 +154,7 @@ module Formtastic
       def selected_values
         if object.respond_to?(method)
           selected_items = [object.send(method)].compact.flatten
-          [*selected_items.map { |o| send_or_call(value_method, o) }].compact
+          [*selected_items.map { |o| send_or_call_or_object(value_method, o) }].compact
         else
           []
         end

data/lib/formtastic/inputs/file_input.rb

@@ -13,7 +13,7 @@ module Formtastic
     #
     #   <%= semantic_form_for(@user, :html => { :multipart => true }) do |f| %>
     #     <%= f.inputs do %>
-    #       <%= f.input :email_address, :as => :email %>
+    #       <%= f.input :avatar, :as => :file %>
     #     <% end %>
     #   <% end %>
     #
@@ -21,8 +21,8 @@ module Formtastic
     #     <fieldset>
     #       <ol>
     #         <li class="email">
-    #           <label for="user_email_address">Email address</label>
-    #           <input type="email" id="user_email_address" name="user[email_address]">
+    #           <label for="user_avatar">Avatar</label>
+    #           <input type="file" id="user_avatar" name="user[avatar]">
     #         </li>
     #       </ol>
     #     </fieldset>
@@ -39,4 +39,4 @@ module Formtastic
       end
     end
   end
-end
+end

data/lib/formtastic/inputs/number_input.rb

@@ -96,7 +96,7 @@ module Formtastic
         return options[:step] if options.key?(:step)
         return validation_step if validation_step
         return 1 if validation_integer_only?
-        1
+        "any"
       end
       
       def min_option

data/lib/formtastic/inputs/radio_input.rb

@@ -140,7 +140,7 @@ module Formtastic
 
       def choice_html(choice)        
         template.content_tag(:label,
-          builder.radio_button(input_name, choice_value(choice), input_html_options.merge(choice_html_options(choice))) << 
+          builder.radio_button(input_name, choice_value(choice), input_html_options.merge(choice_html_options(choice)).merge(:required => false)) << 
           choice_label(choice),
           label_html_options.merge(:for => choice_input_dom_id(choice), :class => nil)
         )

data/lib/formtastic/inputs/time_input.rb

@@ -1,16 +1,38 @@
 module Formtastic
   module Inputs
     # Outputs a series of select boxes for the fragments that make up a time (hour, minute, second).
+    # Unless `:ignore_date` is true, it will render hidden inputs for the year, month and day as 
+    # well, defaulting to `Time.current` if the form object doesn't have a value, much like Rails' 
+    # own `time_select`.
     #
     # @see Formtastic::Inputs::Timeish Timeish module for documetation of date, time and datetime input options.
     class TimeInput 
       include Base
       include Base::Timeish
       
-      # we don't want year / month / day fragments in a time select
-      def date_fragments
-        []
+      # we don't want year / month / day fragments if :ignore_date => true
+      def fragments
+        time_fragments
       end
+      
+      def value_or_default_value
+        value ? value : Time.current
+      end
+      
+      def fragment_value(fragment)
+        value_or_default_value.send(fragment)
+      end
+      
+      def hidden_fragments
+        if !options[:ignore_date]
+          date_fragments.map do |fragment|
+            template.hidden_field_tag("#{object_name}[#{fragment_name(fragment)}]", fragment_value(fragment), :id => fragment_id(fragment), :disabled => input_html_options[:disabled] )
+          end.join.html_safe
+        else
+          super
+        end
+      end
+      
     end
   end
 end

data/lib/formtastic/version.rb

@@ -1,3 +1,3 @@
 module Formtastic
-  VERSION = "2.0.0.rc3"
+  VERSION = "2.0.0.rc4"
 end

data/lib/generators/templates/formtastic.rb

@@ -66,8 +66,17 @@
 # Specifies if labels/hints for input fields automatically be looked up using I18n.
 # Default value: true. Overridden for specific fields by setting value to true,
 # i.e. :label => true, or :hint => true (or opposite depending on initialized value)
-# Formtastic::FormBuilder_lookups_by_default = false
+# Formtastic::FormBuilder.i18n_lookups_by_default = false
 
 # You can add custom inputs or override parts of Formtastic by subclassing Formtastic::FormBuilder and
 # specifying that class here.  Defaults to Formtastic::FormBuilder.
 # Formtastic::Helpers::FormHelper.builder = MyCustomBuilder
+
+# You can opt out of Formtastic's use of the HTML5 `required` attribute on `<input>`, `<select>` 
+# and `<textarea>` tags by setting this to false (defaults to true).
+# Formtastic::FormBuilder.use_required_attribute = false
+
+# You can opt out of new HTML5 browser validations (for things like email and url inputs) by setting
+# this to false. Doing so will add a `novalidate` attribute to the `<form>` tag.
+# See http://diveintohtml5.org/forms.html#validation for more info.
+# Formtastic::FormBuilder.perform_browser_validations = true

data/spec/builder/errors_spec.rb

@@ -107,6 +107,16 @@ describe 'Formtastic::FormBuilder#errors_on' do
       output_buffer.should_not have_tag('p.inine-errors')
       output_buffer.should_not have_tag('ul.errors')
     end
+    
+    it 'should allow calling deprecated errors_on and inline_errors_for helpers' do
+      Formtastic::FormBuilder.inline_errors = :sentence
+      with_deprecation_silenced do
+        concat(semantic_form_for(@new_post) do |builder|
+          builder.errors_on :title
+          builder.inline_errors_for :title
+        end)
+      end
+    end
 
   end
 

data/spec/builder/semantic_fields_for_spec.rb

@@ -11,51 +11,93 @@ describe 'Formtastic::FormBuilder#fields_for' do
     @new_post.stub!(:author).and_return(::Author.new)
   end
 
-  it 'yields an instance of FormHelper.builder' do
-    semantic_form_for(@new_post) do |builder|
-      builder.fields_for(:author) do |nested_builder|
+  context 'outside a form_for block' do
+    it 'yields an instance of FormHelper.builder' do
+      semantic_fields_for(@new_post) do |nested_builder|
+        nested_builder.class.should == Formtastic::Helpers::FormHelper.builder
+      end
+      semantic_fields_for(@new_post.author) do |nested_builder|
+        nested_builder.class.should == Formtastic::Helpers::FormHelper.builder
+      end
+      semantic_fields_for(:author, @new_post.author) do |nested_builder|
+        nested_builder.class.should == Formtastic::Helpers::FormHelper.builder
+      end
+      semantic_fields_for(:author, @hash_backed_author) do |nested_builder|
         nested_builder.class.should == Formtastic::Helpers::FormHelper.builder
       end
     end
-  end
-
-  it 'nests the object name' do
-    semantic_form_for(@new_post) do |builder|
-      builder.fields_for(@bob) do |nested_builder|
-        nested_builder.object_name.should == 'post[author]'
+    
+    it 'should respond to input' do
+      semantic_fields_for(@new_post) do |nested_builder|
+        nested_builder.respond_to?(:input).should be_true
+      end
+      semantic_fields_for(@new_post.author) do |nested_builder|
+        nested_builder.respond_to?(:input).should be_true
+      end
+      semantic_fields_for(:author, @new_post.author) do |nested_builder|
+        nested_builder.respond_to?(:input).should be_true
+      end
+      semantic_fields_for(:author, @hash_backed_author) do |nested_builder|
+        nested_builder.respond_to?(:input).should be_true
       end
     end
   end
   
-  it 'supports passing collection as second parameter' do
-    semantic_form_for(@new_post) do |builder|
-      builder.semantic_fields_for(:author, [@fred,@bob]) do |nested_builder|
-        nested_builder.object_name.should =~ /post\[author_attributes\]\[\d+\]/
+  context 'within a form_for block' do
+    it 'yields an instance of FormHelper.builder' do
+      semantic_form_for(@new_post) do |builder|
+        builder.semantic_fields_for(:author) do |nested_builder|
+          nested_builder.class.should == Formtastic::Helpers::FormHelper.builder
+        end
       end
     end
-  end
-
-  it 'should sanitize html id for li tag' do
-    @bob.stub!(:column_for_attribute).and_return(mock('column', :type => :string, :limit => 255))
-    concat(semantic_form_for(@new_post) do |builder|
-      concat(builder.fields_for(@bob, :index => 1) do |nested_builder|
-        concat(nested_builder.inputs(:login))
+    
+    it 'yields an instance of FormHelper.builder with hash-like model' do
+      semantic_form_for(:user) do |builder|
+        builder.semantic_fields_for(:author, @hash_backed_author) do |nested_builder|
+          nested_builder.class.should == Formtastic::Helpers::FormHelper.builder
+        end
+      end
+    end
+    
+    it 'nests the object name' do
+      semantic_form_for(@new_post) do |builder|
+        builder.semantic_fields_for(@bob) do |nested_builder|
+          nested_builder.object_name.should == 'post[author]'
+        end
+      end
+    end
+    
+    it 'supports passing collection as second parameter' do
+      semantic_form_for(@new_post) do |builder|
+        builder.semantic_fields_for(:author, [@fred,@bob]) do |nested_builder|
+          nested_builder.object_name.should =~ /post\[author_attributes\]\[\d+\]/
+        end
+      end
+    end
+    
+    it 'should sanitize html id for li tag' do
+      @bob.stub!(:column_for_attribute).and_return(mock('column', :type => :string, :limit => 255))
+      concat(semantic_form_for(@new_post) do |builder|
+        concat(builder.semantic_fields_for(@bob, :index => 1) do |nested_builder|
+          concat(nested_builder.inputs(:login))
+        end)
       end)
-    end)
-    output_buffer.should have_tag('form fieldset.inputs #post_author_1_login_input')
-    # Not valid selector, so using good ol' regex
-    output_buffer.should_not =~ /id="post\[author\]_1_login_input"/
-    # <=> output_buffer.should_not have_tag('form fieldset.inputs #post[author]_1_login_input')
-  end
-
-  it 'should use namespace provided in nested fields' do
-    @bob.stub!(:column_for_attribute).and_return(mock('column', :type => :string, :limit => 255))
-    concat(semantic_form_for(@new_post, :namespace => 'context2') do |builder|
-      concat(builder.fields_for(@bob, :index => 1) do |nested_builder|
-        concat(nested_builder.inputs(:login))
+      output_buffer.should have_tag('form fieldset.inputs #post_author_1_login_input')
+      # Not valid selector, so using good ol' regex
+      output_buffer.should_not =~ /id="post\[author\]_1_login_input"/
+      # <=> output_buffer.should_not have_tag('form fieldset.inputs #post[author]_1_login_input')
+    end
+    
+    it 'should use namespace provided in nested fields' do
+      @bob.stub!(:column_for_attribute).and_return(mock('column', :type => :string, :limit => 255))
+      concat(semantic_form_for(@new_post, :namespace => 'context2') do |builder|
+        concat(builder.semantic_fields_for(@bob, :index => 1) do |nested_builder|
+          concat(nested_builder.inputs(:login))
+        end)
       end)
-    end)
-    output_buffer.should have_tag('form fieldset.inputs #context2_post_author_1_login_input')
+      output_buffer.should have_tag('form fieldset.inputs #context2_post_author_1_login_input')
+    end
   end
   
   context "when I rendered my own hidden id input" do 
@@ -68,7 +110,7 @@ describe 'Formtastic::FormBuilder#fields_for' do
       @fred.stub!(:posts_attributes=)
 
       concat(semantic_form_for(@fred) do |builder|
-        concat(builder.fields_for(:posts) do |nested_builder|
+        concat(builder.semantic_fields_for(:posts) do |nested_builder|
           concat(nested_builder.input(:id, :as => :hidden))
           concat(nested_builder.input(:title))
         end)
@@ -85,4 +127,3 @@ describe 'Formtastic::FormBuilder#fields_for' do
   end
 
 end
-

data/spec/helpers/form_helper_spec.rb

@@ -23,6 +23,38 @@ describe 'FormHelper' do
       end)
       output_buffer.should have_tag("form.formtastic")
     end
+    
+    it 'adds a "novalidate" attribute to the generated form when configured to do so' do
+      with_config :perform_browser_validations, true do
+        concat(semantic_form_for(@new_post, :url => '/hello') do |builder|
+        end)
+        output_buffer.should_not have_tag("form[@novalidate]")
+      end
+    end
+    
+    it 'omits a "novalidate" attribute to the generated form when configured to do so' do
+      with_config :perform_browser_validations, false do
+        concat(semantic_form_for(@new_post, :url => '/hello') do |builder|
+        end)
+        output_buffer.should have_tag("form[@novalidate]")
+      end
+    end
+
+    it 'allows form HTML to override "novalidate" attribute when configure to not show' do
+      with_config :perform_browser_validations, false do
+        concat(semantic_form_for(@new_post, :url => '/hello', :html => { :novalidate => true }) do |builder|
+        end)
+        output_buffer.should have_tag("form[@novalidate]")
+      end
+    end
+
+    it 'allows form HTML to override "novalidate" attribute when configure to show' do
+      with_config :perform_browser_validations, true do
+        concat(semantic_form_for(@new_post, :url => '/hello', :html => { :novalidate => false }) do |builder|
+        end)
+        output_buffer.should_not have_tag("form[@novalidate]")
+      end
+    end
 
     it 'adds a class of "xyz" to the generated form' do
       Formtastic::Helpers::FormHelper.default_form_class = 'xyz'

data/spec/helpers/input_helper_spec.rb

@@ -8,18 +8,18 @@ describe 'Formtastic::FormBuilder#input' do
   before do
     @output_buffer = ''
     mock_everything
-    
+
     @errors = mock('errors')
     @errors.stub!(:[]).and_return([])
     @new_post.stub!(:errors).and_return(@errors)
   end
-  
+
   after do
     ::I18n.backend.reload!
   end
-  
+
   describe 'arguments and options' do
-  
+
     it 'should require the first argument (the method on form\'s object)' do
       lambda {
         concat(semantic_form_for(@new_post) do |builder|
@@ -31,7 +31,7 @@ describe 'Formtastic::FormBuilder#input' do
     describe ':required option' do
 
       describe 'when true' do
-        
+
         it 'should set a "required" class' do
           with_config :required_string, " required yo!" do
             concat(semantic_form_for(@new_post) do |builder|
@@ -114,21 +114,21 @@ describe 'Formtastic::FormBuilder#input' do
           before do
             @new_post.stub!(:class).and_return(::PostModel)
           end
-        
+
           after do
             @new_post.stub!(:class).and_return(::Post)
           end
           describe 'and validates_presence_of was called for the method' do
             it 'should be required' do
-        
+
               @new_post.class.should_receive(:validators_on).with(:title).any_number_of_times.and_return([
                 active_model_presence_validator([:title])
               ])
-        
+
               @new_post.class.should_receive(:validators_on).with(:body).any_number_of_times.and_return([
                 active_model_presence_validator([:body], {:if => true})
               ])
-        
+
               concat(semantic_form_for(@new_post) do |builder|
                 concat(builder.input(:title))
                 concat(builder.input(:body))
@@ -136,84 +136,169 @@ describe 'Formtastic::FormBuilder#input' do
               output_buffer.should have_tag('form li.required')
               output_buffer.should_not have_tag('form li.optional')
             end
-        
+
+            it 'should be required when there is :on => :create option on create' do
+              with_config :required_string, " required yo!" do
+                @new_post.class.should_receive(:validators_on).with(:title).any_number_of_times.and_return([
+                  active_model_presence_validator([:title], {:on => :create})
+                ])
+                concat(semantic_form_for(@new_post) do |builder|
+                  concat(builder.input(:title))
+                end)
+                output_buffer.should have_tag('form li.required')
+                output_buffer.should_not have_tag('form li.optional')
+              end
+            end
+
+            it 'should be required when there is :on => :save option on create' do
+              with_config :required_string, " required yo!" do
+                @new_post.class.should_receive(:validators_on).with(:title).any_number_of_times.and_return([
+                  active_model_presence_validator([:title], {:on => :save})
+                ])
+                concat(semantic_form_for(@new_post) do |builder|
+                  concat(builder.input(:title))
+                end)
+                output_buffer.should have_tag('form li.required')
+                output_buffer.should_not have_tag('form li.optional')
+              end
+            end
+
+            it 'should be required when there is :on => :save option on update' do
+              with_config :required_string, " required yo!" do
+                @fred.class.should_receive(:validators_on).with(:login).any_number_of_times.and_return([
+                  active_model_presence_validator([:login], {:on => :save})
+                ])
+                concat(semantic_form_for(@fred) do |builder|
+                  concat(builder.input(:login))
+                end)
+                output_buffer.should have_tag('form li.required')
+                output_buffer.should_not have_tag('form li.optional')
+              end
+            end
+
+            it 'should not be required when there is :on => :create option on update' do
+              @fred.class.should_receive(:validators_on).with(:login).any_number_of_times.and_return([
+                active_model_presence_validator([:login], {:on => :create})
+              ])
+              concat(semantic_form_for(@fred) do |builder|
+                concat(builder.input(:login))
+              end)
+              output_buffer.should_not have_tag('form li.required')
+              output_buffer.should have_tag('form li.optional')
+            end
+
+            it 'should not be required when there is :on => :update option on create' do
+              @new_post.class.should_receive(:validators_on).with(:title).any_number_of_times.and_return([
+                active_model_presence_validator([:title], {:on => :update})
+              ])
+              concat(semantic_form_for(@new_post) do |builder|
+                concat(builder.input(:title))
+              end)
+              output_buffer.should_not have_tag('form li.required')
+              output_buffer.should have_tag('form li.optional')
+            end
+
             it 'should be not be required if the optional :if condition is not satisifed' do
-              should_be_required(:required => false, :options => { :if => false })
+              presence_should_be_required(:required => false, :tag => :body, :options => { :if => false })
             end
-        
+
             it 'should not be required if the optional :if proc evaluates to false' do
-              should_be_required(:required => false, :options => { :if => proc { |record| false } })
+              presence_should_be_required(:required => false, :tag => :body, :options => { :if => proc { |record| false } })
             end
-        
+
             it 'should be required if the optional :if proc evaluates to true' do
-              should_be_required(:required => true, :options => { :if => proc { |record| true } })
+              presence_should_be_required(:required => true, :tag => :body, :options => { :if => proc { |record| true } })
             end
-        
+
             it 'should not be required if the optional :unless proc evaluates to true' do
-              should_be_required(:required => false, :options => { :unless => proc { |record| true } })
+              presence_should_be_required(:required => false, :tag => :body, :options => { :unless => proc { |record| true } })
             end
-        
+
             it 'should be required if the optional :unless proc evaluates to false' do
-              should_be_required(:required => true, :options => { :unless => proc { |record| false } })
+              presence_should_be_required(:required => true, :tag => :body, :options => { :unless => proc { |record| false } })
             end
-        
+
             it 'should be required if the optional :if with a method string evaluates to true' do
               @new_post.should_receive(:required_condition).and_return(true)
-              should_be_required(:required => true, :options => { :if => :required_condition })
+              presence_should_be_required(:required => true, :tag => :body, :options => { :if => :required_condition })
             end
-        
+
             it 'should be required if the optional :if with a method string evaluates to false' do
               @new_post.should_receive(:required_condition).and_return(false)
-              should_be_required(:required => false, :options => { :if => :required_condition })
+              presence_should_be_required(:required => false, :tag => :body, :options => { :if => :required_condition })
             end
-        
-            it 'should not be required if the optional :unless with a method string evaluates to false' do
+
+            it 'should be required if the optional :unless with a method string evaluates to false' do
                @new_post.should_receive(:required_condition).and_return(false)
-              should_be_required(:required => true, :options => { :unless => :required_condition })
+              presence_should_be_required(:required => true, :tag => :body, :options => { :unless => :required_condition })
             end
-        
-             it 'should be required if the optional :unless with a method string evaluates to true' do
+
+             it 'should not be required if the optional :unless with a method string evaluates to true' do
                @new_post.should_receive(:required_condition).and_return(true)
-               should_be_required(:required => false, :options => { :unless => :required_condition })
+               presence_should_be_required(:required => false, :tag => :body, :options => { :unless => :required_condition })
              end
           end
-        
+
           describe 'and validates_inclusion_of was called for the method' do
             it 'should be required' do
               @new_post.class.should_receive(:validators_on).with(:published).any_number_of_times.and_return([
                 active_model_inclusion_validator([:published], {:in => [false, true]})
               ])
-        
-              concat(semantic_form_for(@new_post) do |builder|
-                concat(builder.input(:published))
-              end)
-              output_buffer.should have_tag('form li.required')
-              output_buffer.should_not have_tag('form li.optional')
+              should_be_required(:tag => :published, :required => true)
             end
-            
+
             it 'should not be required if allow_blank is true' do
               @new_post.class.should_receive(:validators_on).with(:published).any_number_of_times.and_return([
                 active_model_inclusion_validator([:published], {:in => [false, true], :allow_blank => true})
               ])
-        
-              concat(semantic_form_for(@new_post) do |builder|
-                concat(builder.input(:published))
-              end)
-              output_buffer.should_not have_tag('form li.required')
-              output_buffer.should have_tag('form li.optional')
+              should_be_required(:tag => :published, :required => false)
             end
           end
-        
+
+          describe 'and validates_length_of was called for the method' do
+            it 'should be required if minimum is set' do
+              length_should_be_required(:tag => :title, :required => true, :options => {:minimum => 1})
+            end
+
+            it 'should be required if :within is set' do
+              length_should_be_required(:tag => :title, :required => true, :options => {:within => 1..5})
+            end
+
+            it 'should not be required if :within allows zero length' do
+              length_should_be_required(:tag => :title, :required => false, :options => {:within => 0..5})
+            end
+
+            it 'should not be required if only :minimum is zero' do
+              length_should_be_required(:tag => :title, :required => false, :options => {:minimum => 0})
+            end
+
+            it 'should not be required if only :minimum is not set' do
+              length_should_be_required(:tag => :title, :required => false, :options => {:maximum => 5})
+            end
+
+            it 'should not be required if allow_blank is true' do
+              length_should_be_required(:tag => :published, :required => false, :options => {:allow_blank => true})
+            end
+          end
+
+          def add_presence_validator(options)
+            @new_post.class.stub!(:validators_on).with(options[:tag]).and_return([
+              active_model_presence_validator([options[:tag]], options[:options])
+            ])
+          end
+
+          def add_length_validator(options)
+            @new_post.class.should_receive(:validators_on).with(options[:tag]).any_number_of_times {[
+              active_model_length_validator([options[:tag]], options[:options])
+            ]}
+          end
+
           # TODO make a matcher for this?
           def should_be_required(options)
-            @new_post.class.stub!(:validators_on).with(:body).and_return([
-              active_model_presence_validator([:body], options[:options])
-            ])
-        
             concat(semantic_form_for(@new_post) do |builder|
-              concat(builder.input(:body))
+              concat(builder.input(options[:tag]))
             end)
-        
+
             if options[:required]
               output_buffer.should_not have_tag('form li.optional')
               output_buffer.should have_tag('form li.required')
@@ -222,24 +307,34 @@ describe 'Formtastic::FormBuilder#input' do
               output_buffer.should_not have_tag('form li.required')
             end
           end
-          
+
+          def presence_should_be_required(options)
+            add_presence_validator(options)
+            should_be_required(options)
+          end
+
+          def length_should_be_required(options)
+            add_length_validator(options)
+            should_be_required(options)
+          end
+
           # TODO JF reversed this during refactor, need to make sure
           describe 'and there are no requirement validations on the method' do
             before do
               @new_post.class.should_receive(:validators_on).with(:title).and_return([])
             end
-        
-            it 'should use the default value' do
+
+            it 'should not be required' do
               concat(semantic_form_for(@new_post) do |builder|
                 concat(builder.input(:title))
               end)
-              output_buffer.should have_tag('form li.required')
-              output_buffer.should_not have_tag('form li.optional')
+              output_buffer.should_not have_tag('form li.required')
+              output_buffer.should have_tag('form li.optional')
             end
           end
-        
+
         end
-        
+
         describe 'and an object without :validators_on' do
 
             it 'should use the default value' do
@@ -304,99 +399,98 @@ describe 'Formtastic::FormBuilder#input' do
           @new_post.stub!(:column_for_attribute).with(:aws_instance_id).and_return(mock('column', :type => :integer))
           default_input_type(:integer, :aws_instance_id).should == :number
         end
-        
+
         it 'should default to :select for associations' do
           @new_post.class.stub!(:reflect_on_association).with(:user_id).and_return(mock('ActiveRecord::Reflection::AssociationReflection'))
           @new_post.class.stub!(:reflect_on_association).with(:section_id).and_return(mock('ActiveRecord::Reflection::AssociationReflection'))
           default_input_type(:integer, :user_id).should == :select
           default_input_type(:integer, :section_id).should == :select
         end
-  
+
         it 'should default to :password for :string column types with "password" in the method name' do
           default_input_type(:string, :password).should == :password
           default_input_type(:string, :hashed_password).should == :password
           default_input_type(:string, :password_hash).should == :password
         end
-  
+
         it 'should default to :text for :text column types' do
           default_input_type(:text).should == :text
         end
-  
+
         it 'should default to :date for :date column types' do
           default_input_type(:date).should == :date
         end
-  
+
         it 'should default to :datetime for :datetime and :timestamp column types' do
           default_input_type(:datetime).should == :datetime
           default_input_type(:timestamp).should == :datetime
         end
-  
+
         it 'should default to :time for :time column types' do
           default_input_type(:time).should == :time
         end
-  
+
         it 'should default to :boolean for :boolean column types' do
           default_input_type(:boolean).should == :boolean
         end
-  
+
         it 'should default to :string for :string column types' do
           default_input_type(:string).should == :string
         end
-  
+
         it 'should default to :number for :integer, :float and :decimal column types' do
           default_input_type(:integer).should == :number
           default_input_type(:float).should == :number
           default_input_type(:decimal).should == :number
         end
-  
+
         it 'should default to :country for :string columns named country' do
           default_input_type(:string, :country).should == :country
         end
-  
+
         it 'should default to :email for :string columns matching email' do
           default_input_type(:string, :email).should == :email
           default_input_type(:string, :customer_email).should == :email
           default_input_type(:string, :email_work).should == :email
         end
-  
+
         it 'should default to :url for :string columns named url or website' do
           default_input_type(:string, :url).should == :url
           default_input_type(:string, :website).should == :url
           default_input_type(:string, :my_url).should == :url
           default_input_type(:string, :hurl).should_not == :url
         end
-  
+
         it 'should default to :phone for :string columns named phone or fax' do
           default_input_type(:string, :phone).should == :phone
           default_input_type(:string, :fax).should == :phone
         end
-  
+
         it 'should default to :search for :string columns named search' do
           default_input_type(:string, :search).should == :search
         end
-  
+
         describe 'defaulting to file column' do
           Formtastic::FormBuilder.file_methods.each do |method|
             it "should default to :file for attributes that respond to ##{method}" do
-              @new_post.stub!(:column_for_attribute).and_return(nil)
               column = mock('column')
-  
+
               Formtastic::FormBuilder.file_methods.each do |test|
                 ### TODO: Check if this is ok
                 column.stub!(method).with(test).and_return(method == test)
               end
-  
+
               @new_post.should_receive(method).and_return(column)
-  
+
               semantic_form_for(@new_post) do |builder|
                 builder.send(:default_input_type, method).should == :file
               end
             end
           end
-  
+
         end
       end
-  
+
       it 'should call the corresponding input class with .to_html' do
         [:select, :time_zone, :radio, :date, :datetime, :time, :boolean, :check_boxes, :hidden, :string, :password, :number, :text, :file].each do |input_style|
           @new_post.stub!(:generic_column_name)
@@ -405,7 +499,7 @@ describe 'Formtastic::FormBuilder#input' do
             input_instance = mock('Input instance')
             input_class = "#{input_style.to_s}_input".classify
             input_constant = "Formtastic::Inputs::#{input_class}".constantize
-            
+
             input_constant.should_receive(:new).and_return(input_instance)
             input_instance.should_receive(:to_html).and_return("some HTML")
 
@@ -738,10 +832,10 @@ describe 'Formtastic::FormBuilder#input' do
     end
 
     describe ':collection option' do
-      
+
       it "should be required on polymorphic associations" do
         @new_post.stub!(:commentable)
-        @new_post.class.stub!(:reflections).and_return({ 
+        @new_post.class.stub!(:reflections).and_return({
           :commentable => mock('macro_reflection', :options => { :polymorphic => true }, :macro => :belongs_to)
         })
         @new_post.stub!(:column_for_attribute).with(:commentable).and_return(
@@ -750,37 +844,37 @@ describe 'Formtastic::FormBuilder#input' do
         @new_post.class.stub!(:reflect_on_association).with(:commentable).and_return(
           mock('reflection', :macro => :belongs_to, :options => { :polymorphic => true })
         )
-        expect { 
+        expect {
           concat(semantic_form_for(@new_post) do |builder|
-            concat(builder.inputs do 
+            concat(builder.inputs do
               concat(builder.input :commentable)
             end)
           end)
         }.to raise_error(Formtastic::PolymorphicInputWithoutCollectionError)
       end
-      
+
     end
 
   end
-  
+
   describe 'options re-use' do
-    
+
     it 'should retain :as option when re-using the same options hash' do
       my_options = { :as => :string }
       output = ''
-      
+
       concat(semantic_form_for(@new_post) do |builder|
         concat(builder.input(:title, my_options))
         concat(builder.input(:publish_at, my_options))
       end)
       output_buffer.should have_tag 'li.string', :count => 2
     end
-    
-    
+
+
   end
-  
+
   describe 'instantiating an input class' do
-    
+
     context 'when a class does not exist' do
       it "should raise an error" do
         lambda {
@@ -790,9 +884,9 @@ describe 'Formtastic::FormBuilder#input' do
         }.should raise_error(Formtastic::UnknownInputError)
       end
     end
-    
+
     context 'when a customized top-level class does not exist' do
-      
+
       it 'should instantiate the Formtastic input' do
         input = mock('input', :to_html => 'some HTML')
         Formtastic::Inputs::StringInput.should_receive(:new).and_return(input)
@@ -800,26 +894,26 @@ describe 'Formtastic::FormBuilder#input' do
           builder.input(:title, :as => :string)
         end)
       end
-      
+
     end
-    
+
     describe 'when a top-level input class exists' do
       it "should instantiate the top-level input instead of the Formtastic one" do
         class ::StringInput < Formtastic::Inputs::StringInput
         end
-        
+
         input = mock('input', :to_html => 'some HTML')
         Formtastic::Inputs::StringInput.should_not_receive(:new).and_return(input)
         ::StringInput.should_receive(:new).and_return(input)
-        
+
         concat(semantic_form_for(@new_post) do |builder|
           builder.input(:title, :as => :string)
         end)
       end
     end
-    
+
     describe 'when instantiated multiple times with the same input type' do
-      
+
       it "should be cached (not calling the internal methods)" do
         # TODO this is really tied to the underlying implementation
         concat(semantic_form_for(@new_post) do |builder|
@@ -828,10 +922,10 @@ describe 'Formtastic::FormBuilder#input' do
           builder.input(:title, :as => :string)
         end)
       end
-      
+
     end
-    
+
   end
-  
+
 end