justinfrench-formtastic 0.1.4 → 0.1.5

data/README.textile

@@ -1,4 +1,4 @@
-h1. Formtastic 0.1.4
+h1. Formtastic 0.1.5
 
 Formtastic is a Rails FormBuilder DSL (with some other goodies) to make it far easier to create beautiful, semantically rich, syntactically awesome, readily stylable and wonderfully accessible HTML forms in your Rails applications.
 
@@ -86,7 +86,7 @@ And then add it as a dependency in your environment.rb file:
   config.gem "justinfrench-formtastic", 
     :lib     => 'formtastic', 
     :source  => 'http://gems.github.com', 
-    :version => '0.1.4'
+    :version => '0.1.5'
 </pre>
 
 If you're a little more old school, install it as a plugin:
@@ -156,18 +156,20 @@ If you want to customize the label text, or render some hint text below the fiel
   <% end %>
 </pre>
 
-If you want to customize html elements for any non button inputs you just need
-to specify the :input_html options hash.
+If you want to customize html elements for any non button inputs and the li
+wrapper you just need to specify the :input_html and :wrapper_html options hash.
 
 <pre>
     <% semantic_form_for @post do |form| %>
       <%= form.input :title, :input_html => {:size => 60} %>
-      <%= form.input :body %>
+      <%= form.input :body, :wrapper_html => { :class => 'body_wrapper' } %>
       <%= form.input :created_at, :input_html => {:disabled => true} %>
       <%= form.buttons %>
     <% end %>
 </pre>
 
+To customize buttons, :button_html is available.
+
 Nested forms (Rails 2.3) are also supported. You can do it in the Rails way:
 
 <pre>
@@ -212,13 +214,13 @@ h2. The Available Inputs
 
 * :select (a select menu) - default for ActiveRecord associations (belongs_to, has_many, has_and_belongs_to_many)
 * :radio (a set of radio inputs) - alternative to :select for ActiveRecord belongs_to associations
+* :time_zone (a select input) - default for :string column types with 'time_zone' in the method name
 * :password (a password input) - default for :string column types with 'password' in the method name
 * :text (a textarea) - default for :text column types
 * :date (a date select) - default for :date column types
 * :datetime (a date and time select) - default for :datetime and :timestamp column types
 * :time (a time select) - default for :time column types
 * :boolean (a checkbox) - default for :boolean column types
-* :boolean_select (a yes/no select box)
 * :string (a text field) - default for :string column types
 * :numeric (a text field, like string) - default for :integer, :float and :decimal column types
 * :file (a file field) - default for paperclip or attachment_fu attributes
@@ -329,21 +331,23 @@ 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.
 
 * "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
+* "Andy Pearson":http://github.com/andypearson
+* "negonicrac":http://github.com/negonicrac
 * "Xavier Shay":http://rhnh.net
-* "Bin Dong":http://github.com/dongbin
-* "Ben Hamill":http://blog.benhamill.com/
 * "Pat Allan":http://github.com/freelancing-god
-* "negonicrac":http://github.com/negonicrac
-* "Andy Pearson":http://github.com/andypearson
-* "Mark Mansour":http://stateofflux.com
-* "Tien Dung":http://github.com/tiendung
-* "Sascha Hoellger":http://github.com/mitnal
-* "Jeff Smick":http://github.com/sprsquish
-* "José Valim":http://github.com/josevalim
-* "Greg Fitzgerald":http://github.com/gregf/
 * "Gareth Townsend":http://github.com/quamen
+* "Sascha Hoellger":http://github.com/mitnal
+* "Andrew Carpenter":http://github.com/andrewcarpenter
 * "Jack Dempsey":http://github.com/jackdempsey/
+* "Greg Fitzgerald":http://github.com/gregf/
+* "Hector E. Gomez Morales":http://github.com/hectoregm
+* "Ben Hamill":http://blog.benhamill.com/
 * "Simon Chiu":http://github.com/tolatomeow
+* "Bin Dong":http://github.com/dongbin
 
 
 h2. Hey, join the Google group!

data/lib/formtastic.rb

@@ -35,7 +35,6 @@ module Formtastic #:nodoc:
     STRING_MAPPINGS = [ :string, :password, :numeric ]
 
     attr_accessor :template
-    attr_writer   :nested_child_index
 
     # Returns a suitable form input for the given +method+, using the database column information
     # and other factors (like the method name) to figure out what you probably want.
@@ -47,6 +46,7 @@ module Formtastic #:nodoc:
     # * :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
+    # * :wrapper_html - provide options that will be passed down to the li wrapper
     #
     # Input Types:
     #
@@ -55,6 +55,7 @@ module Formtastic #:nodoc:
     # columns all map to a single numeric_input, for example).
     #
     # * :select (a select menu for associations) - default to association names
+    # * :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
@@ -77,29 +78,25 @@ module Formtastic #:nodoc:
     #   <% end %>
     #
     def input(method, options = {})
-      options[:required] = method_required?(method, options[:required])
+      options[:required] = method_required?(method) unless options.key?(:required)
       options[:as]     ||= default_input_type(method)
 
-      options[:label]  ||= if @object
-        @object.class.human_attribute_name(method.to_s)
-      else
-        method.to_s.send(@@label_str_method)
-      end
+      html_class = [ options[:as], (options[:required] ? :required : :optional) ]
+      html_class << 'error' if @object && @object.respond_to?(:errors) && @object.errors.on(method.to_s)
+
+      wrapper_html = options.delete(:wrapper_html) || {}
+      wrapper_html[:id]  ||= generate_html_id(method)
+      wrapper_html[:class] = (html_class << wrapper_html[:class]).flatten.compact.join(' ')
 
       if [:boolean_select, :boolean_radio].include?(options[:as])
         ::ActiveSupport::Deprecation.warn(":as => :#{options[:as]} is deprecated, use :as => :#{options[:as].to_s[8..-1]} instead", caller[3..-1])
       end
 
-      html_class = [ options[:as], (options[:required] ? :required : :optional) ].join(' ')
-      html_class << ' error' if @object && @object.errors.on(method.to_s)
-
-      html_id = generate_html_id(method)
-
       list_item_content = @@inline_order.map do |type|
         send(:"inline_#{type}_for", method, options)
       end.compact.join("\n")
 
-      return template.content_tag(:li, list_item_content, { :id => html_id, :class => html_class })
+      return template.content_tag(:li, list_item_content, wrapper_html)
     end
 
     # Creates an input fieldset and ol tag wrapping for use around a set of inputs.  It can be
@@ -233,21 +230,15 @@ module Formtastic #:nodoc:
       html_options = args.extract_options!
       html_options[:class] ||= "inputs"
 
-      if fields_for_object = html_options.delete(:for)
-        html_options.merge!(:parent_builder => self)
-        inputs_for_nested_attributes(fields_for_object, args << html_options,
-                                     html_options.delete(:for_options) || {}, &block)
+      if html_options[:for]
+        inputs_for_nested_attributes(args, html_options, &block)
       elsif block_given?
         field_set_and_list_wrapping(html_options, &block)
       else
         if @object && args.empty?
-          # Get all belongs_to association
           args  = @object.class.reflections.map { |n,_| n if _.macro == :belongs_to }
-
-          # Get content columns and remove timestamps columns from it
           args += @object.class.content_columns.map(&:name)
           args -= %w[created_at updated_at created_on updated_on]
-
           args.compact!
         end
         contents = args.map { |method| input(method.to_sym) }
@@ -285,9 +276,10 @@ module Formtastic #:nodoc:
     #
     #  <%= form.commit_button "Go" %> => <input name="commit" type="submit" value="Go" />
     #
-    def commit_button(value=nil, options = {})
-      value ||= save_or_create_button_text
-      template.content_tag(:li, template.submit_tag(value), :class => "commit")
+    def commit_button(value=nil, options={})
+      value     ||= save_or_create_button_text
+      button_html = options.delete(:button_html) || {}
+      template.content_tag(:li, self.submit(value, button_html), :class => "commit")
     end
 
     # A thin wrapper around #fields_for to set :builder => Formtastic::SemanticFormBuilder
@@ -316,6 +308,25 @@ 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.
+    #
+    # :required can be also sent as option. When true, marks a filed as required,
+    # when false marks it as optional. When nil, does nothing.
+    #
+    def label(method, text, options={}, as_span=false)
+      text ||= humanized_attribute_name(method)
+      text  << required_or_optional_string(options.delete(:required))
+
+      if as_span
+        options[:class] ||= 'label'
+        template.content_tag(:span, text, options)
+      else
+        super(method, text, options)
+      end
+    end
+
     protected
 
     # Deals with :for option when it's supplied to inputs methods. Additional
@@ -324,17 +335,20 @@ module Formtastic #:nodoc:
     #
     # It should raise an error if a block with arity zero is given.
     #
-    def inputs_for_nested_attributes(fields_for_object, inputs, options, &block)
+    def inputs_for_nested_attributes(args, options, &block)
+      args << options.merge!(:parent => { :builder => self, :for => options[:for] })
+
       fields_for_block = if block_given?
         raise ArgumentError, 'You gave :for option with a block to inputs method, ' <<
                              'but the block does not accept any argument.' if block.arity <= 0
 
-        proc { |f| f.inputs(*inputs){ block.call(f) } }
+        proc { |f| f.inputs(*args){ block.call(f) } }
       else
-        proc { |f| f.inputs(*inputs) }
+        proc { |f| f.inputs(*args) }
       end
 
-      semantic_fields_for(*(Array(fields_for_object) << options), &fields_for_block)
+      fields_for_args = [options.delete(:for), options.delete(:for_options) || {}].flatten
+      semantic_fields_for(*fields_for_args, &fields_for_block)
     end
 
     # Remove any Formtastic-specific options before passing the down options.
@@ -374,9 +388,7 @@ module Formtastic #:nodoc:
     # * if the :required option isn't provided, and the plugin isn't available, the value of the
     #   configuration option @@all_fields_required_by_default is used.
     #
-    def method_required?(attribute, required_option) #:nodoc:
-      return required_option unless required_option.nil?
-
+    def method_required?(attribute) #:nodoc:
       if @object && @object.class.respond_to?(:reflect_on_all_validations)
         attribute_sym = attribute.to_s.sub(/_id$/, '').to_sym
 
@@ -398,7 +410,8 @@ module Formtastic #:nodoc:
       html_options = options.delete(:input_html) || {}
       html_options = default_string_options(method).merge(html_options) if STRING_MAPPINGS.include?(type)
 
-      input_label(method, options.delete(:label), options.slice(:required)) + send(INPUT_MAPPINGS[type], method, html_options)
+      self.label(method, options.delete(:label), options.slice(:required)) +
+      self.send(INPUT_MAPPINGS[type], method, html_options)
     end
 
     # Outputs a label and a select box containing options from the parent
@@ -490,11 +503,25 @@ module Formtastic #:nodoc:
        end
 
       input_name = generate_association_input_name(method)
-      input_label(input_name, options.delete(:label), options.slice(:required)) +
+      self.label(input_name, options.delete(:label), options.slice(:required)) +
       self.select(input_name, collection, set_options(options), html_options)
     end
     alias :boolean_select_input :select_input
 
+    # Outputs a timezone select input as Rails' time_zone_select helper. You
+    # can give priority zones as option.
+    #
+    # Examples:
+    #
+    #   f.input :time_zone, :as => :time_zone, :priority_zones => /Australia/
+    #
+    def time_zone_input(method, options)
+      html_options = options.delete(:input_html) || {}
+
+      self.label(method, options.delete(:label), options.slice(:required)) +
+      self.time_zone_select(method, options.delete(:priority_zones), set_options(options), html_options)
+    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 radio input.
@@ -668,18 +695,16 @@ module Formtastic #:nodoc:
 
     # Outputs a label containing a checkbox and the label text. The label defaults
     # to the column name (method name) and can be altered with the :label option.
-    #
-    # Different from other inputs, :required options has no effect here and
     # :checked_value and :unchecked_value options are also available.
     #
     def boolean_input(method, options)
       html_options = options.delete(:input_html) || {}
 
-      content = self.check_box(method, set_options(options).merge(html_options),
-                               options.delete(:checked_value) || '1', options.delete(:unchecked_value) || '0')
+      input = self.check_box(method, set_options(options).merge(html_options),
+                             options.delete(:checked_value) || '1', options.delete(:unchecked_value) || '0')
 
-      # required does not make sense in check box
-      input_label(method, content + options.delete(:label), :skip_required => true)
+      label = options.delete(:label) || humanized_attribute_name(method)
+      self.label(method, input + label, options.slice(:required))
     end
 
     # Generates an input for the given method using the type supplied with :as.
@@ -703,16 +728,24 @@ module Formtastic #:nodoc:
     # or as sentence. If :none is set, no error is shown.
     #
     def inline_errors_for(method, options)  #:nodoc:
-      return nil unless @object && [:sentence, :list].include?(@@inline_errors)
+      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
 
-      errors = @object.errors.on(method.to_s).to_a
       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:
-      options[:hint].blank? ? '' : template.content_tag(:p, options[:hint], :class => 'inline-hints')
+      return if options[:hint].blank?
+      template.content_tag(:p, options[:hint], :class => 'inline-hints')
     end
 
     # Creates an error sentence by calling to_sentence on the errors array.
@@ -731,31 +764,23 @@ module Formtastic #:nodoc:
       template.content_tag(:ul, list_elements.join("\n"), :class => 'errors')
     end
 
-    # Generates the label for the input. Accepts the same options as Rails label
-    # method and a fourth option that allows the label to be generated as span
-    # with class label.
-    #
-    def input_label(method, text, options={}, as_span=false) #:nodoc:
-      text << required_or_optional_string(options.delete(:required)) unless options.delete(:skip_required)
-
-      if as_span
-        options[:class] ||= 'label'
-        template.content_tag(:span, text, options)
-      else
-        self.label(method, text, options)
-      end
-    end
-
     # Generates the required or optional string. If the value set is a proc,
     # it evaluates the proc first.
     #
     def required_or_optional_string(required) #:nodoc:
-      string_or_proc = required ? @@required_string : @@optional_string
+      string_or_proc = case required
+        when true
+          @@required_string
+        when false
+          @@optional_string
+        else
+          required
+      end
 
-      if string_or_proc.is_a? Proc
+      if string_or_proc.is_a?(Proc)
         string_or_proc.call
       else
-        string_or_proc
+        string_or_proc.to_s
       end
     end
 
@@ -768,23 +793,18 @@ module Formtastic #:nodoc:
     # And it will generate a fieldset for each task with legend 'Task #1', 'Task #2',
     # 'Task #3' and so on.
     #
-    # If you are using inputs :for, for more than one association in the same
-    # form builder, you might want to set the nested_child_index as well. You
-    # can do that doing:
-    #
-    #   f.nested_child_index = -1
-    #
-    def field_set_and_list_wrapping(html_options, contents = '', &block) #:nodoc:
-      # Generates the legend text allowing nested_child_index support for interpolation
-      legend_text  = html_options.delete(:name).to_s
-      legend_text %= html_options[:parent_builder].instance_variable_get('@nested_child_index').to_i + 1
+    def field_set_and_list_wrapping(html_options, contents='', &block) #:nodoc:
+      legend  = html_options.delete(:name).to_s
+      legend %= parent_child_index(html_options[:parent]) if html_options[:parent]
+      legend  = template.content_tag(:legend, template.content_tag(:span, legend)) unless legend.blank?
 
-      legend = legend_text.blank? ? "" : template.content_tag(:legend, template.content_tag(:span, legend_text))
       contents = template.capture(&block) if block_given?
 
+      # Ruby 1.9: String#to_s behavior changed, need to make an explicit join.
+      contents = contents.join if contents.respond_to?(:join)
       fieldset = template.content_tag(:fieldset,
         legend + template.content_tag(:ol, contents),
-        html_options.except(:builder, :parent_builder)
+        html_options.except(:builder, :parent)
       )
 
       template.concat(fieldset) if block_given?
@@ -796,12 +816,12 @@ module Formtastic #:nodoc:
     #
     def field_set_and_list_wrapping_for_method(method, options, contents)
       template.content_tag(:fieldset,
-        %{<legend>#{input_label(method, options.delete(:label), options.slice(:required), true)}</legend>} +
+        %{<legend>#{self.label(method, options.delete(:label), options.slice(:required), true)}</legend>} +
         template.content_tag(:ol, contents)
       )
     end
 
-    # For methods that have a database column, take a best guess as to what the inout method
+    # For methods that have a database column, take a best guess as to what the input method
     # should be.  In most cases, it will just return the column type (eg :string), but for special
     # cases it will simplify (like the case of :integer, :float & :decimal to :numeric), or do
     # something different (like :password and :select).
@@ -812,23 +832,22 @@ module Formtastic #:nodoc:
     def default_input_type(method) #:nodoc:
       return :string if @object.nil?
 
-      # Find the column object by attribute
       column = @object.column_for_attribute(method) if @object.respond_to?(:column_for_attribute)
 
-      # Associations map by default to a select
-      return :select if column.nil? && find_reflection(method)
-
       if column
         # handle the special cases where the column type doesn't map to an input method
-        return :select   if column.type == :integer && method.to_s =~ /_id$/
-        return :datetime if column.type == :timestamp
-        return :numeric  if [:integer, :float, :decimal].include?(column.type)
-        return :password if column.type == :string && method.to_s =~ /password/
+        return :time_zone if column.type == :string && method.to_s =~ /time_zone/
+        return :select    if column.type == :integer && method.to_s =~ /_id$/
+        return :datetime  if column.type == :timestamp
+        return :numeric   if [:integer, :float, :decimal].include?(column.type)
+        return :password  if column.type == :string && method.to_s =~ /password/
+
         # otherwise assume the input name will be the same as the column type (eg string_input)
         return column.type
       else
         obj = @object.send(method) if @object.respond_to?(method)
 
+        return :select   if find_reflection(method)
         return :file     if obj && @@file_methods.any? { |m| obj.respond_to?(m) }
         return :password if method.to_s =~ /password/
         return :string
@@ -913,7 +932,7 @@ module Formtastic #:nodoc:
     # reflection object.
     #
     def find_reflection(method)
-      object.class.reflect_on_association(method) if object.class.respond_to?(:reflect_on_association)
+      @object.class.reflect_on_association(method) if @object.class.respond_to?(:reflect_on_association)
     end
 
     # Generates default_string_options by retrieving column information from
@@ -947,10 +966,34 @@ module Formtastic #:nodoc:
       "#{sanitized_object_name}#{index}_#{sanitized_method_name}_#{value}"
     end
 
+    # Gets the nested_child_index value from the parent builder. In Rails 2.3
+    # it always returns a fixnum. In next versions it returns a hash with each
+    # association that the parent builds.
+    #
+    def parent_child_index(parent)
+      duck = parent[:builder].instance_variable_get('@nested_child_index')
+
+      if duck.is_a?(Hash)
+        child = parent[:for]
+        child = child.first if child.respond_to?(:first)
+        duck[child].to_i + 1
+      else
+        duck.to_i + 1
+      end
+    end
+
     def sanitized_object_name
       @sanitized_object_name ||= @object_name.to_s.gsub(/\]\[|[^-a-zA-Z0-9:.]/, "_").sub(/_$/, "")
     end
 
+    def humanized_attribute_name(method)
+      if @object && @object.class.respond_to?(:human_attribute_name)
+        @object.class.human_attribute_name(method.to_s)
+      else
+        method.to_s.send(@@label_str_method)
+      end
+    end
+
   end
 
   # Wrappers around form_for (etc) with :builder => SemanticFormBuilder.

data/spec/formtastic_spec.rb

@@ -561,7 +561,7 @@ describe 'Formtastic' do
           end
 
           it 'should call the corresponding input method' do
-            [:select, :radio, :date, :datetime, :time, :boolean].each do |input_style|
+            [:select, :time_zone, :radio, :date, :datetime, :time, :boolean].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|
@@ -647,6 +647,47 @@ describe 'Formtastic' do
           end
 
         end
+
+        describe ':wrapper_html option' do
+
+          describe 'when provided' do
+            it 'should be passed down to the li tag' do
+              semantic_form_for(@new_post) do |builder|
+                concat(builder.input(:title, :wrapper_html => {:id => :another_id}))
+              end
+              output_buffer.should have_tag("form li#another_id")
+            end
+
+            it 'should append given classes to li default classes' do
+              semantic_form_for(@new_post) do |builder|
+                concat(builder.input(:title, :wrapper_html => {:class => :another_class}, :required => true))
+              end
+              output_buffer.should have_tag("form li.string")
+              output_buffer.should have_tag("form li.required")
+              output_buffer.should have_tag("form li.another_class")
+            end
+
+            it 'should allow classes to be an array' do
+              semantic_form_for(@new_post) do |builder|
+                concat(builder.input(:title, :wrapper_html => {:class => [ :my_class, :another_class ]}))
+              end
+              output_buffer.should have_tag("form li.string")
+              output_buffer.should have_tag("form li.my_class")
+              output_buffer.should have_tag("form li.another_class")
+            end
+          end
+
+          describe 'when not provided' do
+            it 'should use default id and class' do
+              semantic_form_for(@new_post) do |builder|
+                concat(builder.input(:title))
+              end
+              output_buffer.should have_tag("form li#post_title_input")
+              output_buffer.should have_tag("form li.string")
+            end
+          end
+
+        end
       end
 
       describe ':as any type of input' do
@@ -971,6 +1012,57 @@ describe 'Formtastic' do
         end
       end
 
+      describe ":as => :time_zone" do
+        before do
+          @new_post.stub!(:time_zone)
+          @new_post.stub!(:column_for_attribute).and_return(mock('column', :type => :string))
+
+          semantic_form_for(@new_post) do |builder|
+            concat(builder.input(:time_zone))
+          end
+        end
+
+        it "should have a time_zone class on the wrapper" do
+          output_buffer.should have_tag('form li.time_zone')
+        end
+
+        it 'should have a post_title_input id on the wrapper' do
+          output_buffer.should have_tag('form li#post_time_zone_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_time_zone"')
+          output_buffer.should have_tag('form li label', /Time zone/)
+        end
+
+        it "should generate a select" do
+          output_buffer.should have_tag("form li select")
+          output_buffer.should have_tag("form li select#post_time_zone")
+          output_buffer.should have_tag("form li select[@name=\"post[time_zone]\"]")
+        end
+
+        it 'should use input_html to style inputs' do
+          semantic_form_for(@new_post) do |builder|
+            concat(builder.input(:time_zone, :input_html => { :class => 'myclass' }))
+          end
+          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))
+          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/)
+
+          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
 
       describe ':as => :radio' do
 
@@ -1145,7 +1237,7 @@ describe 'Formtastic' do
 
           it 'should have a label inside the wrapper' do
             output_buffer.should have_tag('form li label')
-            output_buffer.should have_tag('form li label', /Posts/)
+            output_buffer.should have_tag('form li label', /Post ids/)
             output_buffer.should have_tag("form li label[@for='author_post_ids']")
           end
 
@@ -1187,7 +1279,7 @@ describe 'Formtastic' do
 
           it 'should have a label inside the wrapper' do
             output_buffer.should have_tag('form li label')
-            output_buffer.should have_tag('form li label', /Authors/)
+            output_buffer.should have_tag('form li label', /Author ids/)
             output_buffer.should have_tag("form li label[@for='post_author_ids']")
           end
 
@@ -1967,7 +2059,7 @@ describe 'Formtastic' do
 
           it 'should send parent_builder as an option to allow child index interpolation' do
             semantic_form_for(@new_post) do |builder|
-              builder.should_receive(:instance_variable_get).with('@nested_child_index').and_return(0)
+              builder.instance_variable_set('@nested_child_index', 0)
               builder.inputs :for => [:author, @bob], :name => 'Author #%i' do |bob_builder|
                 concat('input')
               end
@@ -1975,6 +2067,17 @@ describe 'Formtastic' do
 
             output_buffer.should have_tag('fieldset legend', 'Author #1')
           end
+
+          it 'should also provide child index interpolation when nested child index is a hash' do
+            semantic_form_for(@new_post) do |builder|
+              builder.instance_variable_set('@nested_child_index', :author => 10)
+              builder.inputs :for => [:author, @bob], :name => 'Author #%i' do |bob_builder|
+                concat('input')
+              end
+            end
+
+            output_buffer.should have_tag('fieldset legend', 'Author #11')
+          end
         end
 
         describe 'when a :name option is provided' do
@@ -2311,6 +2414,16 @@ describe 'Formtastic' do
           output_buffer.should have_tag('li.commit input[@name="commit"]')
         end
 
+        it 'should pass options given in :button_html to the button' do
+          @new_post.stub!(:new_record?).and_return(false)
+          semantic_form_for(@new_post) do |builder|
+            concat(builder.commit_button('text', :button_html => {:class => 'my_class', :id => 'my_id'}))
+          end
+
+          output_buffer.should have_tag('li.commit input#my_id')
+          output_buffer.should have_tag('li.commit input.my_class')
+        end
+
       end
 
       describe 'when used on an existing record' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: justinfrench-formtastic
 version: !ruby/object:Gem::Version 
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors: 
 - Justin French
@@ -9,7 +9,7 @@ autorequire: formtastic
 bindir: bin
 cert_chain: []
 
-date: 2009-04-10 00:00:00 -07:00
+date: 2009-04-19 00:00:00 -07:00
 default_executable: 
 dependencies: []