forme 0.9.2 → 0.10.0

data/lib/forme/rails.rb

@@ -53,8 +53,8 @@ module Forme
       
       # If a block is not given, emit the inputs into the current output
       # buffer.
-      def _inputs(*)
-        if block_given?
+      def _inputs(inputs=[], opts={}) # :nodoc:
+        if block_given? && !opts[:subform]
           super
         else
           emit(super)
@@ -83,8 +83,8 @@ module Forme
           template.raw(tag.to_s)
         end
       end
-
-      def tag_(type, attr={}, children=[])
+      
+      def tag_(type, attr={}, children=[]) # :nodoc:
         tag = _tag(type, attr, children)
         emit(serializer.serialize_open(tag)) if serializer.respond_to?(:serialize_open)
         Array(tag.children).each{|c| emit(c)}

data/lib/forme/version.rb

@@ -1,6 +1,6 @@
 module Forme
   # Version constant, use <tt>Forme.version</tt> instead.
-  VERSION = '0.9.2'.freeze
+  VERSION = '0.10.0'.freeze
 
   # Returns the version as a frozen string (e.g. '0.1.0')
   def self.version

data/lib/sequel/plugins/forme.rb

@@ -15,18 +15,6 @@ module Sequel # :nodoc:
       # that use a <tt>Sequel::Model</tt> instance as the form's
       # +obj+.
       module SequelForm
-        # Stack of objects used by subform.  The current +obj+
-        # is added to the top of the stack on a call to +subform+,
-        # the nested associated object is set as the current +obj+ during the
-        # call to +subform+, and when +subform+ returns, the top of the
-        # stack is set as the current +obj+.
-        attr_accessor :nested_associations
-
-        # The namespaces that should be added to the id and name
-        # attributes for the receiver's inputs.  Used as a stack
-        # by +subform+.
-        attr_accessor :namespaces
-
         # Use the post method by default for Sequel forms, unless
         # overridden with the :method attribute.
         def form(attr={}, &block)
@@ -53,26 +41,31 @@ module Sequel # :nodoc:
         # :inputs :: Automatically call +inputs+ with the given values.  Using
         #            this, it is not required to pass a block to the method,
         #            though it will still work if you do.
-        # :legend :: If :inputs is also used, this is passed to it to override
-        #            the default :legend used.  You can also use a proc as the value,
+        # :legend :: Overrides the default :legend used (which is based on the
+        #            association name).  You can also use a proc as the value,
         #            which will called with each associated object (and the position
         #            in the associated object already for *_to_many associations),
         #            and should return the legend string to use for that object.
+        # :grid :: Sets up a table with one row per associated object, and
+        #          one column per field.
+        # :labels :: When using the :grid option, override the labels that would
+        #            be created via the :inputs option.  If you are not providing
+        #            an :inputs option or are using a block with additional inputs,
+        #            you should specify this option.
         def subform(association, opts={}, &block)
           nested_obj = opts.has_key?(:obj) ? opts[:obj] : obj.send(association)
           ref = obj.class.association_reflection(association)
           multiple = ref.returns_array?
-          i = -1
-          ins = opts[:inputs]
-          Array(nested_obj).each do |no|
-            begin
-              nested_associations << obj
-              namespaces << "#{association}_attributes"
-              namespaces << (i+=1) if multiple
-              @obj = no
-              emit(input(ref.associated_class.primary_key, :type=>:hidden, :label=>nil)) unless no.new?
-              if ins
-                options = opts.dup
+          grid = opts[:grid]
+          ns = "#{association}_attributes"
+
+          contents = proc do
+            send(multiple ? :each_obj : :with_obj, nested_obj, ns) do |no, i|
+              emit(input(ref.associated_class.primary_key, :type=>:hidden, :label=>nil, :wrapper=>nil)) unless no.new?
+              options = opts.dup
+              if grid
+                options.delete(:legend)
+              else
                 if options.has_key?(:legend)
                   if options[:legend].respond_to?(:call)
                     options[:legend] = multiple ? options[:legend].call(no, i) : options[:legend].call(no)
@@ -84,32 +77,21 @@ module Sequel # :nodoc:
                     options[:legend] = humanize(association)
                   end
                 end
-                _inputs(ins, options, &block)  
-              else
-                yield
               end
-            ensure
-              @obj = nested_associations.pop
-              namespaces.pop if multiple
-              namespaces.pop
+              options[:subform] = true
+              _inputs(options[:inputs]||[], options, &block)
             end
           end
+          
+          if grid
+            labels = opts.fetch(:labels){opts[:inputs].map{|l, *| humanize(l)} if opts[:inputs]}
+            legend = opts.fetch(:legend){humanize(association)}
+            inputs({:inputs_wrapper=>:table, :nested_inputs_wrapper=>:tr, :wrapper=>:td, :labeler=>nil, :labels=>labels, :legend=>legend}, &contents)
+          else
+            contents.call
+          end
           nil
         end
-
-        # Return a unique id attribute for the +field+, handling
-        # nested attributes use.
-        def namespaced_id(field)
-          "#{namespaces.join('_')}_#{field}"
-        end
-
-        # Return a unique name attribute for the +field+, handling nested
-        # attribute use.  If +multiple+ is true, end the name
-        # with [] so that param parsing will treat the name as part of an array.
-        def namespaced_name(field, multiple=false)
-          root, *nsps = namespaces
-          "#{root}#{nsps.map{|n| "[#{n}]"}.join}[#{field}]#{'[]' if multiple}"
-        end
       end
 
       # Helper class for dealing with Forme/Sequel integration.
@@ -157,8 +139,7 @@ module Sequel # :nodoc:
           type = opts[:type]
           if !type && (sch = obj.db_schema[field])
             meth = :"input_#{sch[:type]}"
-            opts[:id] = form.namespaced_id(field) unless opts.has_key?(:id)
-            opts[:name] = form.namespaced_name(field) unless opts.has_key?(:name)
+            opts[:key] = field unless opts.has_key?(:key)
             opts[:required] = true if !opts.has_key?(:required) && sch[:allow_null] == false && sch[:type] != :boolean
             handle_label(field)
 
@@ -183,8 +164,7 @@ module Sequel # :nodoc:
             raise(Error, "Unrecognized field used: #{field}") unless rt || type
             meth = :"input_#{type}"
             opts[:value] = nil unless rt || opts.has_key?(:value)
-            opts[:id] = form.namespaced_id(field) unless opts.has_key?(:id)
-            opts[:name] = form.namespaced_name(field, opts[:multiple]) unless opts.has_key?(:name)
+            opts[:key] = field unless opts.has_key?(:key)
             handle_label(field)
             if respond_to?(meth, true)
               opts.delete(:type)
@@ -217,22 +197,6 @@ module Sequel # :nodoc:
           opts[:label] = [opts[:label], form._tag(:abbr, {:title=>'required'}, '*')] if opts[:required]
         end
 
-        # Add the label to the start of the array, returning the array.
-        def add_label(label, array)
-          array.unshift(form._tag(:span, {:class=>:label}, label)) if label
-          array
-        end
-
-        # Unset the wrapper and tag_wrapper options and return a
-        # array with the wrapper and tag_wrapper to use.  The tag_wrapper
-        # is for wrapping each individual tag.
-        def get_wrappers
-          tag_wrapper = opts.delete(:tag_wrapper) || :default
-          wrapper = form.transformer(:wrapper, opts)
-          opts.delete(:wrapper)
-          [wrapper, tag_wrapper]
-        end
-
         # Update the attributes and options for any recognized validations
         def handle_validations(f)
           m = obj.model
@@ -296,19 +260,13 @@ module Sequel # :nodoc:
         def association_many_to_one(ref)
           key = ref[:key]
           handle_errors(key)
-          opts[:name] = form.namespaced_name(key) unless opts.has_key?(:name)
+          opts[:key] = key unless opts.has_key?(:key)
           opts[:value] = obj.send(key) unless opts.has_key?(:value)
           opts[:options] = association_select_options(ref) unless opts.has_key?(:options)
           if opts.delete(:as) == :radio
             handle_label(field)
-            label = opts.delete(:label)
-            val = opts.delete(:value)
-            wrapper, tag_wrapper = get_wrappers
-            radios = opts.delete(:options).map{|l, pk| _input(:radio, opts.merge(:value=>pk, :id=>"#{form.namespaced_id(key)}_#{pk}", :wrapper=>tag_wrapper, :label=>l, :label_attr=>{:class=>:option}, :checked=>(pk == val)))}
-            add_label(label, radios)
-            wrapper ? wrapper.call(radios, _input(:radio, opts)) : radios
+            _input(:radioset, opts)
           else
-            opts[:id] = form.namespaced_id(key) unless opts.has_key?(:id)
             opts[:required] = true if !opts.has_key?(:required) && (sch = obj.model.db_schema[key]) && !sch[:allow_null]
             opts[:add_blank] = true if !opts.has_key?(:add_blank) && !(opts[:required] && opts[:value])
             handle_label(field)
@@ -327,19 +285,16 @@ module Sequel # :nodoc:
           klass = ref.associated_class
           pk = klass.primary_key
           field = "#{klass.send(:singularize, ref[:name])}_pks"
-          opts[:name] = form.namespaced_name(field, :multiple) unless opts.has_key?(:name)
+          unless opts.has_key?(:key)
+            opts[:array] = true unless opts.has_key?(:array)
+            opts[:key] = field
+          end
           opts[:value] = obj.send(ref[:name]).map{|x| x.send(pk)} unless opts.has_key?(:value)
           opts[:options] = association_select_options(ref) unless opts.has_key?(:options)
           handle_label(field)
           if opts.delete(:as) == :checkbox
-            label = opts.delete(:label)
-            val = opts.delete(:value)
-            wrapper, tag_wrapper = get_wrappers
-            cbs = opts.delete(:options).map{|l, pk| _input(:checkbox, opts.merge(:value=>pk, :id=>"#{form.namespaced_id(field)}_#{pk}", :wrapper=>tag_wrapper, :label=>l, :label_attr=>{:class=>:option}, :checked=>val.include?(pk), :no_hidden=>true))}
-            add_label(label, cbs)
-            wrapper ? wrapper.call(cbs, _input(:checkbox, opts)) : cbs
+            _input(:checkboxset, opts)
           else
-            opts[:id] = form.namespaced_id(field) unless opts.has_key?(:id)
             opts[:multiple] = true unless opts.has_key?(:multiple)
             _input(:select, opts)
           end
@@ -385,19 +340,14 @@ module Sequel # :nodoc:
 
           case opts[:as]
           when :radio
-            wrapper, tag_wrapper = get_wrappers
-            true_opts = opts.merge(:value=>opts[:true_value]||'t', :label=>opts[:true_label]||'Yes', :label_attr=>{:class=>:option}, :error=>nil, :wrapper=>tag_wrapper, :wrapper_attr=>{})
-            false_opts = opts.merge(:value=>opts[:false_value]||'f', :label=>opts[:false_label]||'No', :label_attr=>{:class=>:option}, :wrapper=>tag_wrapper, :wrapper_attr=>{})
-            if i = opts[:id]
-              true_opts[:id] = "#{i}_yes"
-              false_opts[:id] = "#{i}_no"
-            end
             v = opts.has_key?(:value) ? opts[:value] : obj.send(field)
+            true_value = opts[:true_value]||'t'
+            false_value = opts[:false_value]||'f'
+            opts[:options] = [[opts[:true_label]||'Yes', {:value=>true_value, :key_id=>'yes'}], [opts[:false_label]||'No', {:value=>false_value, :key_id=>'no'}]]
             unless v.nil?
-              (v ? true_opts : false_opts)[:checked] = true
+              opts[:value] = v ? true_value : false_value
             end
-            array = add_label(opts[:label], [_input(:radio, true_opts), _input(:radio, false_opts)])
-            wrapper ? wrapper.call(array, _input(:radio, opts)) : array
+            _input(:radioset, opts)
           when :select
             v = opts[:value] || obj.send(field)
             opts[:value] = (v ? 't' : 'f') unless v.nil?
@@ -487,8 +437,7 @@ module Sequel # :nodoc:
         # specific code, such as support for nested attributes.
         def forme_config(form)
           form.extend(SequelForm)
-          form.nested_associations = []
-          form.namespaces = [model.send(:underscore, model.name)]
+          form.namespaces << model.send(:underscore, model.name)
           form.extend(SinatraSequelForm) if defined?(::Forme::Sinatra::Form) && form.is_a?(::Forme::Sinatra::Form)
         end
 

data/spec/forme_coverage.rb

@@ -0,0 +1,13 @@
+require 'coverage'
+require 'simplecov'
+
+def SimpleCov.forme_coverage(opts = {})
+  start do
+    add_filter "/spec/"
+    add_group('Missing'){|src| src.covered_percent < 100}
+    add_group('Covered'){|src| src.covered_percent == 100}
+    yield self if block_given?
+  end
+end
+
+ENV.delete('COVERAGE')

data/spec/forme_spec.rb

@@ -45,6 +45,136 @@ describe "Forme plain forms" do
     @f.input(:text, :style=>"foo").to_s.should == '<input style="foo" type="text"/>'
   end
 
+  specify "should use :key option as name and id attributes" do
+    @f.input(:text, :key=>"foo").to_s.should == '<input id="foo" name="foo" type="text"/>'
+  end
+
+  specify "should use :key_id option as suffix for :key option id attributes" do
+    @f.input(:text, :key=>"foo", :key_id=>'bar').to_s.should == '<input id="foo_bar" name="foo" type="text"/>'
+  end
+
+  specify "should have :key option respect :multiple option" do
+    @f.input(:text, :key=>"foo", :multiple=>true).to_s.should == '<input id="foo" name="foo[]" type="text"/>'
+  end
+
+  specify "should use :key option respect form's current namespace" do
+    @f.with_opts(:namespace=>['bar']) do
+      @f.input(:text, :key=>"foo").to_s.should == '<input id="bar_foo" name="bar[foo]" type="text"/>'
+      @f.input(:text, :key=>"foo", :multiple=>true).to_s.should == '<input id="bar_foo" name="bar[foo][]" type="text"/>'
+      @f.with_opts(:namespace=>['bar', 'baz']) do
+        @f.input(:text, :key=>"foo").to_s.should == '<input id="bar_baz_foo" name="bar[baz][foo]" type="text"/>'
+      end
+    end
+  end
+
+  specify "should consider form's :values hash for default values based on the :key option if :value is not present" do
+    @f.opts[:values] = {'foo'=>'baz'}
+    @f.input(:text, :key=>"foo").to_s.should == '<input id="foo" name="foo" type="text" value="baz"/>'
+    @f.input(:text, :key=>"foo", :value=>'x').to_s.should == '<input id="foo" name="foo" type="text" value="x"/>'
+
+    @f.input(:text, :key=>:foo).to_s.should == '<input id="foo" name="foo" type="text" value="baz"/>'
+    @f.opts[:values] = {:foo=>'baz'}
+    @f.input(:text, :key=>:foo).to_s.should == '<input id="foo" name="foo" type="text" value="baz"/>'
+  end
+
+  specify "should consider form's :values hash for default values based on the :key option when using namespaces" do
+    @f.opts[:values] = {'bar'=>{'foo'=>'baz'}}
+    @f.with_opts(:namespace=>['bar']) do
+      @f.input(:text, :key=>"foo").to_s.should == '<input id="bar_foo" name="bar[foo]" type="text" value="baz"/>'
+      @f.input(:text, :key=>"foo", :value=>'x').to_s.should == '<input id="bar_foo" name="bar[foo]" type="text" value="x"/>'
+      @f.input(:text, :key=>:foo).to_s.should == '<input id="bar_foo" name="bar[foo]" type="text" value="baz"/>'
+    end
+
+    @f.with_opts(:namespace=>[:bar]) do
+      @f.input(:text, :key=>:foo).to_s.should == '<input id="bar_foo" name="bar[foo]" type="text" value="baz"/>'
+
+      @f.opts[:values] = {:bar=>{:foo=>'baz'}}
+      @f.input(:text, :key=>:foo).to_s.should == '<input id="bar_foo" name="bar[foo]" type="text" value="baz"/>'
+      @f.opts[:values] = {:bar=>{}}
+      @f.input(:text, :key=>:foo).to_s.should == '<input id="bar_foo" name="bar[foo]" type="text"/>'
+      @f.opts[:values] = {}
+      @f.input(:text, :key=>:foo).to_s.should == '<input id="bar_foo" name="bar[foo]" type="text"/>'
+
+      @f.opts[:values] = {'bar'=>{'quux'=>{'foo'=>'baz'}}}
+      @f.with_opts(:namespace=>['bar', 'quux']) do
+        @f.input(:text, :key=>"foo").to_s.should == '<input id="bar_quux_foo" name="bar[quux][foo]" type="text" value="baz"/>'
+      end
+    end
+  end
+
+  specify "should support a with_obj method that changes the object and namespace for the given block" do
+    @f.with_obj([:a, :c], 'bar') do
+      @f.input(:first).to_s.should == '<input id="bar_first" name="bar[first]" type="text" value="a"/>'
+      @f.with_obj([:b], 'baz') do
+        @f.input(:first).to_s.should == '<input id="bar_baz_first" name="bar[baz][first]" type="text" value="b"/>'
+      end
+      @f.with_obj([:b], %w'baz quux') do
+        @f.input(:first).to_s.should == '<input id="bar_baz_quux_first" name="bar[baz][quux][first]" type="text" value="b"/>'
+      end
+      @f.with_obj([:b]) do
+        @f.input(:first).to_s.should == '<input id="bar_first" name="bar[first]" type="text" value="b"/>'
+      end
+      @f.input(:last).to_s.should == '<input id="bar_last" name="bar[last]" type="text" value="c"/>'
+    end
+  end
+
+  specify "should support a each_obj method that changes the object and namespace for multiple objects for the given block" do
+    @f.tag(:form) do
+      @f.each_obj([[:a, :c], [:b, :d]], 'bar') do
+        @f.input(:first)
+        @f.input(:last)
+      end
+    end.to_s.should == '<form><input id="bar_0_first" name="bar[0][first]" type="text" value="a"/><input id="bar_0_last" name="bar[0][last]" type="text" value="c"/><input id="bar_1_first" name="bar[1][first]" type="text" value="b"/><input id="bar_1_last" name="bar[1][last]" type="text" value="d"/></form>'
+
+    @f.tag(:form) do
+      @f.each_obj([[:a, :c], [:b, :d]], %w'bar baz') do
+        @f.input(:first)
+        @f.input(:last)
+      end
+    end.to_s.should == '<form><input id="bar_baz_0_first" name="bar[baz][0][first]" type="text" value="a"/><input id="bar_baz_0_last" name="bar[baz][0][last]" type="text" value="c"/><input id="bar_baz_1_first" name="bar[baz][1][first]" type="text" value="b"/><input id="bar_baz_1_last" name="bar[baz][1][last]" type="text" value="d"/></form>'
+
+    @f.tag(:form) do
+      @f.each_obj([[:a, :c], [:b, :d]]) do
+        @f.input(:first)
+        @f.input(:last)
+      end
+    end.to_s.should == '<form><input id="0_first" name="0[first]" type="text" value="a"/><input id="0_last" name="0[last]" type="text" value="c"/><input id="1_first" name="1[first]" type="text" value="b"/><input id="1_last" name="1[last]" type="text" value="d"/></form>'
+  end
+
+  specify "should allow overriding form inputs on a per-block basis" do
+    @f.input(:text).to_s.should == '<input type="text"/>'
+    @f.with_opts(:wrapper=>:div){@f.input(:text).to_s}.should == '<div><input type="text"/></div>'
+    @f.with_opts(:wrapper=>:div){@f.input(:text).to_s.should == '<div><input type="text"/></div>'}
+    @f.with_opts(:wrapper=>:div) do
+      @f.input(:text).to_s.should == '<div><input type="text"/></div>'
+      @f.with_opts(:wrapper=>:li){@f.input(:text).to_s.should == '<li><input type="text"/></li>'}
+      @f.input(:text).to_s.should == '<div><input type="text"/></div>'
+    end
+    @f.input(:text).to_s.should == '<input type="text"/>'
+  end
+
+  specify "should handle delayed formatting when overriding form inputs on a per-block basis" do
+    @f.form do
+      @f.input(:text)
+      @f.with_opts(:wrapper=>:div) do
+        @f.input(:text)
+        @f.with_opts(:wrapper=>:li){@f.input(:text)}
+        @f.input(:text)
+      end
+      @f.input(:text)
+    end.to_s.should == '<form><input type="text"/><div><input type="text"/></div><li><input type="text"/></li><div><input type="text"/></div><input type="text"/></form>'
+  end
+
+  specify "should support :obj method to with_opts for changing the obj inside the block" do
+    @f.form do
+      @f.with_opts(:obj=>[:a, :c]) do
+        @f.input(:first)
+        @f.with_opts(:obj=>[:b]){@f.input(:first)}
+        @f.input(:last)
+      end
+    end.to_s.should == '<form><input id="first" name="first" type="text" value="a"/><input id="first" name="first" type="text" value="b"/><input id="last" name="last" type="text" value="c"/></form>'
+  end
+
   specify "should allow arbitrary attributes using the :attr option" do
     @f.input(:text, :attr=>{:bar=>"foo"}).to_s.should == '<input bar="foo" type="text"/>'
   end
@@ -157,10 +287,95 @@ describe "Forme plain forms" do
     @f.input(:select, :options=>[[:b, 2], [:c, 3]], :add_blank=>true, :value=>2).to_s.should == '<select><option value=""></option><option selected="selected" value="2">b</option><option value="3">c</option></select>'
   end
 
+  specify "should use Forme.default_add_blank_prompt value if :add_blank option is true" do
+    begin
+      Forme.default_add_blank_prompt = 'foo'
+      @f.input(:select, :options=>[[:b, 2], [:c, 3]], :add_blank=>true, :value=>2).to_s.should == '<select><option value="">foo</option><option selected="selected" value="2">b</option><option value="3">c</option></select>'
+    ensure
+      Forme.default_add_blank_prompt = nil
+    end
+  end
+
   specify "should use :add_blank option value as prompt if it is a String" do
     @f.input(:select, :options=>[[:b, 2], [:c, 3]], :add_blank=>"Prompt Here", :value=>2).to_s.should == '<select><option value="">Prompt Here</option><option selected="selected" value="2">b</option><option value="3">c</option></select>'
   end
 
+  specify "should create set of radio buttons" do
+    @f.input(:radioset, :options=>[1, 2, 3], :selected=>2).to_s.should == '<label class="option"><input type="radio" value="1"/> 1</label><label class="option"><input checked="checked" type="radio" value="2"/> 2</label><label class="option"><input type="radio" value="3"/> 3</label>'
+    @f.input(:radioset, :options=>[1, 2, 3], :value=>2).to_s.should == '<label class="option"><input type="radio" value="1"/> 1</label><label class="option"><input checked="checked" type="radio" value="2"/> 2</label><label class="option"><input type="radio" value="3"/> 3</label>'
+  end
+
+  specify "should create set of radio buttons with options and values" do
+    @f.input(:radioset, :options=>[[:a, 1], [:b, 2], [:c, 3]], :selected=>2).to_s.should == '<label class="option"><input type="radio" value="1"/> a</label><label class="option"><input checked="checked" type="radio" value="2"/> b</label><label class="option"><input type="radio" value="3"/> c</label>'
+  end
+
+  specify "should create set of radio buttons with options and values with hashes" do
+    @f.input(:radioset, :options=>[[:a, {:attr=>{:foo=>1}}], [:b, {:class=>'foo', :value=>2}], [:c, {:id=>:baz}]], :selected=>2).to_s.should == '<label class="option"><input foo="1" type="radio" value="a"/> a</label><label class="option"><input checked="checked" class="foo" type="radio" value="2"/> b</label><label class="option"><input id="baz" type="radio" value="c"/> c</label>'
+  end
+
+  specify "should create set of radio buttons with options and values using given method" do
+    @f.input(:radioset, :options=>[[:a, 1], [:b, 2], [:c, 3]], :text_method=>:last, :selected=>2).to_s.should == '<label class="option"><input type="radio" value="1"/> 1</label><label class="option"><input checked="checked" type="radio" value="2"/> 2</label><label class="option"><input type="radio" value="3"/> 3</label>'
+    @f.input(:radioset, :options=>[[:a, 1], [:b, 2], [:c, 3]], :text_method=>:last, :value_method=>:first, :selected=>:b).to_s.should == '<label class="option"><input type="radio" value="a"/> 1</label><label class="option"><input checked="checked" type="radio" value="b"/> 2</label><label class="option"><input type="radio" value="c"/> 3</label>'
+  end
+
+  specify "should support :add_blank option for radioset inputs" do
+    @f.input(:radioset, :options=>[[:b, 2], [:c, 3]], :add_blank=>true, :value=>2).to_s.should == '<label class="option"><input type="radio" value=""/> </label><label class="option"><input checked="checked" type="radio" value="2"/> b</label><label class="option"><input type="radio" value="3"/> c</label>'
+  end
+
+  specify "should use :add_blank option value as prompt if it is a String" do
+    @f.input(:radioset, :options=>[[:b, 2], [:c, 3]], :add_blank=>"Prompt Here", :value=>2).to_s.should == '<label class="option"><input type="radio" value=""/> Prompt Here</label><label class="option"><input checked="checked" type="radio" value="2"/> b</label><label class="option"><input type="radio" value="3"/> c</label>'
+  end
+
+  specify "should respect the :key option for radio sets" do
+    @f.input(:radioset, :options=>[1, 2, 3], :key=>:foo, :value=>2).to_s.should == '<label class="option"><input id="foo_1" name="foo" type="radio" value="1"/> 1</label><label class="option"><input checked="checked" id="foo_2" name="foo" type="radio" value="2"/> 2</label><label class="option"><input id="foo_3" name="foo" type="radio" value="3"/> 3</label>'
+  end
+
+  specify "should create set of checkbox buttons" do
+    @f.input(:checkboxset, :options=>[1, 2, 3], :selected=>2).to_s.should == '<label class="option"><input type="checkbox" value="1"/> 1</label><label class="option"><input checked="checked" type="checkbox" value="2"/> 2</label><label class="option"><input type="checkbox" value="3"/> 3</label>'
+    @f.input(:checkboxset, :options=>[1, 2, 3], :value=>2).to_s.should == '<label class="option"><input type="checkbox" value="1"/> 1</label><label class="option"><input checked="checked" type="checkbox" value="2"/> 2</label><label class="option"><input type="checkbox" value="3"/> 3</label>'
+  end
+
+  specify "should create set of checkbox buttons with options and values" do
+    @f.input(:checkboxset, :options=>[[:a, 1], [:b, 2], [:c, 3]], :selected=>2).to_s.should == '<label class="option"><input type="checkbox" value="1"/> a</label><label class="option"><input checked="checked" type="checkbox" value="2"/> b</label><label class="option"><input type="checkbox" value="3"/> c</label>'
+  end
+
+  specify "should create set of checkbox buttons with options and values with hashes" do
+    @f.input(:checkboxset, :options=>[[:a, {:attr=>{:foo=>1}}], [:b, {:class=>'foo', :value=>2}], [:c, {:id=>:baz}]], :selected=>2).to_s.should == '<label class="option"><input foo="1" type="checkbox" value="a"/> a</label><label class="option"><input checked="checked" class="foo" type="checkbox" value="2"/> b</label><label class="option"><input id="baz" type="checkbox" value="c"/> c</label>'
+  end
+
+  specify "should create set of checkbox buttons with options and values using given method" do
+    @f.input(:checkboxset, :options=>[[:a, 1], [:b, 2], [:c, 3]], :text_method=>:last, :selected=>2).to_s.should == '<label class="option"><input type="checkbox" value="1"/> 1</label><label class="option"><input checked="checked" type="checkbox" value="2"/> 2</label><label class="option"><input type="checkbox" value="3"/> 3</label>'
+    @f.input(:checkboxset, :options=>[[:a, 1], [:b, 2], [:c, 3]], :text_method=>:last, :value_method=>:first, :selected=>:b).to_s.should == '<label class="option"><input type="checkbox" value="a"/> 1</label><label class="option"><input checked="checked" type="checkbox" value="b"/> 2</label><label class="option"><input type="checkbox" value="c"/> 3</label>'
+  end
+
+  specify "should support :add_blank option for checkboxset inputs" do
+    @f.input(:checkboxset, :options=>[[:b, 2], [:c, 3]], :add_blank=>true, :value=>2).to_s.should == '<label class="option"><input type="checkbox" value=""/> </label><label class="option"><input checked="checked" type="checkbox" value="2"/> b</label><label class="option"><input type="checkbox" value="3"/> c</label>'
+  end
+
+  specify "should use :add_blank option value as prompt if it is a String" do
+    @f.input(:checkboxset, :options=>[[:b, 2], [:c, 3]], :add_blank=>"Prompt Here", :value=>2).to_s.should == '<label class="option"><input type="checkbox" value=""/> Prompt Here</label><label class="option"><input checked="checked" type="checkbox" value="2"/> b</label><label class="option"><input type="checkbox" value="3"/> c</label>'
+  end
+
+  specify "should respect the :key option for checkbox sets" do
+    @f.input(:checkboxset, :options=>[1, 2, 3], :key=>:foo, :value=>2).to_s.should == '<label class="option"><input id="foo_1" name="foo[]" type="checkbox" value="1"/> 1</label><label class="option"><input checked="checked" id="foo_2" name="foo[]" type="checkbox" value="2"/> 2</label><label class="option"><input id="foo_3" name="foo[]" type="checkbox" value="3"/> 3</label>'
+  end
+
+  specify "should prefer the :name option to :key option for checkbox sets" do
+    @f.input(:checkboxset, :options=>[1, 2, 3], :key=>:foo, :name=>'bar[]', :value=>2).to_s.should == '<label class="option"><input id="foo_1" name="bar[]" type="checkbox" value="1"/> 1</label><label class="option"><input checked="checked" id="foo_2" name="bar[]" type="checkbox" value="2"/> 2</label><label class="option"><input id="foo_3" name="bar[]" type="checkbox" value="3"/> 3</label>'
+  end
+
+  specify "should prefer the :name and :id option to :key option for checkbox sets" do
+    @f.input(:checkboxset, :options=>[1, 2, 3], :key=>:foo, :name=>'bar[]', :id=>:baz, :value=>2).to_s.should == '<label class="option"><input id="baz_1" name="bar[]" type="checkbox" value="1"/> 1</label><label class="option"><input checked="checked" id="baz_2" name="bar[]" type="checkbox" value="2"/> 2</label><label class="option"><input id="baz_3" name="bar[]" type="checkbox" value="3"/> 3</label>'
+  end
+
+  specify "should respect the :error option for checkbox sets" do
+    @f.input(:checkboxset, :options=>[1, 2, 3], :error=>'foo', :value=>2).to_s.should == '<label class="option"><input type="checkbox" value="1"/> 1</label><label class="option"><input checked="checked" type="checkbox" value="2"/> 2</label><label class="option"><input class="error" type="checkbox" value="3"/> 3</label><span class="error_message">foo</span>'
+  end
+
+  specify "should raise an Error for empty checkbox sets" do
+    @f.input(:checkboxset, :options=>[], :error=>'foo', :value=>2).to_s.should == '<span class="error_message">foo</span>'
+  end
+
   specify "radio and checkbox inputs should handle :checked option" do
     @f.input(:radio, :checked=>true).to_s.should == '<input checked="checked" type="radio"/>'
     @f.input(:radio, :checked=>false).to_s.should == '<input type="radio"/>'
@@ -168,6 +383,11 @@ describe "Forme plain forms" do
     @f.input(:checkbox, :checked=>false).to_s.should == '<input type="checkbox"/>'
   end
 
+  specify "inputs should handle :autofocus option" do
+    @f.input(:text, :autofocus=>true).to_s.should == '<input autofocus="autofocus" type="text"/>'
+    @f.input(:text, :autofocus=>false).to_s.should == '<input type="text"/>'
+  end
+
   specify "inputs should handle :required option" do
     @f.input(:text, :required=>true).to_s.should == '<input required="required" type="text"/>'
     @f.input(:text, :required=>false).to_s.should == '<input type="text"/>'
@@ -283,6 +503,14 @@ describe "Forme plain forms" do
     @f.inputs([[:textarea, {:name=>'foo'}], [:text, {:id=>'bar'}]]).to_s.should == '<fieldset class="inputs"><textarea name="foo"></textarea><input id="bar" type="text"/></fieldset>'
   end
 
+  specify "should have #inputs accept transformer options to modify the options inside the inputs" do
+    @f.inputs([:textarea, :text], :wrapper=>:div).to_s.should == '<fieldset class="inputs"><div><textarea></textarea></div><div><input type="text"/></div></fieldset>'
+  end
+
+  specify "should have #inputs accept :nested_inputs_wrapper options to modify the :input_wrapper option inside the inputs" do
+    @f.inputs(:nested_inputs_wrapper=>:div){@f.inputs([:textarea, :text])}.to_s.should == '<fieldset class="inputs"><div><textarea></textarea><input type="text"/></div></fieldset>'
+  end
+
   specify "should escape tag content" do
     @f.tag(:div, {}, ['<p></p>']).to_s.should == '<div>&lt;p&gt;&lt;/p&gt;</div>'
   end
@@ -376,8 +604,14 @@ describe "Forme plain forms" do
     f.input(:textarea, :name=>"foo").to_s.should == '<textarea cols="80" name="foo" rows="6"></textarea>'
   end
 
+  specify "should work with input_defaults with symbol keys using using inputs with symbol keys" do
+    f = Forme::Form.new(:input_defaults=>{:text=>{:size=>20}, 'text'=>{:size=>30}})
+    f.input(:text, :name=>"foo").to_s.should == '<input name="foo" size="20" type="text"/>'
+    f.input('text', :name=>"foo").to_s.should == '<input name="foo" size="30" type="text"/>'
+  end
+
   specify "invalid custom transformers should raise an Error" do
-    proc{Forme::Form.new(:wrapper=>Object.new)}.should raise_error(Forme::Error)
+    proc{Forme::Form.new(:wrapper=>Object.new).input(:text).to_s}.should raise_error(Forme::Error)
     proc{@f.input(:textarea, :wrapper=>Object.new).to_s}.should raise_error(Forme::Error)
     proc{@f.input(:textarea, :formatter=>nil).to_s}.should raise_error(Forme::Error)
   end
@@ -415,11 +649,11 @@ end
 
 describe "Forme custom" do
   specify "formatters can be specified as a proc" do
-    Forme::Form.new(:formatter=>proc{|i| i.form._tag(:textarea, i.opts.map{|k,v| [v.upcase, k.to_s.downcase]})}).input(:text, :name=>'foo').to_s.should == '<textarea FOO="name"></textarea>'
+    Forme::Form.new(:formatter=>proc{|i| i.form._tag(:textarea, i.opts[:name]=>:name)}).input(:text, :name=>'foo').to_s.should == '<textarea foo="name"></textarea>'
   end
 
   specify "serializers can be specified as a proc" do
-    Forme::Form.new(:serializer=>proc{|t| "#{t.type} = #{t.opts.inspect}"}).input(:textarea, :name=>'foo').to_s.should == 'textarea = {:name=>"foo"}'
+    Forme::Form.new(:serializer=>proc{|t| "#{t.type} = #{t.opts[:name]}"}).input(:textarea, :name=>'foo').to_s.should == 'textarea = foo'
   end
 
   specify "labelers can be specified as a proc" do
@@ -441,7 +675,7 @@ end
 
 describe "Forme built-in custom" do
   specify "transformers should raise if the there is no matching transformer" do
-    proc{Forme::Form.new(:formatter=>:foo)}.should raise_error(Forme::Error)
+    proc{Forme::Form.new(:formatter=>:foo).input(:text).to_s}.should raise_error(Forme::Error)
   end
 
   specify "formatter: disabled disables all inputs unless :disabled=>false option" do
@@ -463,28 +697,42 @@ describe "Forme built-in custom" do
     Forme::Form.new(:labeler=>:explicit).input(:textarea, :id=>'foo', :label=>'bar').to_s.should == '<label for="foo">bar</label><textarea id="foo"></textarea>'
   end
 
+  specify "labeler: explicit handles the key option correctly" do
+    Forme::Form.new(:labeler=>:explicit, :namespace=>:baz).input(:textarea, :key=>'foo', :label=>'bar').to_s.should == '<label for="baz_foo">bar</label><textarea id="baz_foo" name="baz[foo]"></textarea>'
+  end
+
   specify "labeler: explicit should handle tags with errors" do
     Forme::Form.new(:labeler=>:explicit).input(:text, :error=>'Bad Stuff!', :value=>'f', :id=>'foo', :label=>'bar').to_s.should == '<label for="foo">bar</label><input class="error" id="foo" type="text" value="f"/><span class="error_message">Bad Stuff!</span>'
   end
 
   specify "wrapper: li wraps tag in an li" do
     Forme::Form.new(:wrapper=>:li).input(:textarea, :id=>'foo').to_s.should == '<li><textarea id="foo"></textarea></li>'
+    Forme::Form.new(:wrapper=>:li).input(:textarea, :id=>'foo', :wrapper_attr=>{:id=>'bar'}).to_s.should == '<li id="bar"><textarea id="foo"></textarea></li>'
   end
 
   specify "wrapper: p wraps tag in an p" do
     Forme::Form.new(:wrapper=>:p).input(:textarea, :id=>'foo').to_s.should == '<p><textarea id="foo"></textarea></p>'
+    Forme::Form.new(:wrapper=>:p).input(:textarea, :id=>'foo', :wrapper_attr=>{:id=>'bar'}).to_s.should == '<p id="bar"><textarea id="foo"></textarea></p>'
   end
 
   specify "wrapper: div wraps tag in an div" do
     Forme::Form.new(:wrapper=>:div).input(:textarea, :id=>'foo').to_s.should == '<div><textarea id="foo"></textarea></div>'
+    Forme::Form.new(:wrapper=>:div).input(:textarea, :id=>'foo', :wrapper_attr=>{:id=>'bar'}).to_s.should == '<div id="bar"><textarea id="foo"></textarea></div>'
   end
 
   specify "wrapper: span wraps tag in an span" do
     Forme::Form.new(:wrapper=>:span).input(:textarea, :id=>'foo').to_s.should == '<span><textarea id="foo"></textarea></span>'
+    Forme::Form.new(:wrapper=>:span).input(:textarea, :id=>'foo', :wrapper_attr=>{:id=>'bar'}).to_s.should == '<span id="bar"><textarea id="foo"></textarea></span>'
+  end
+
+  specify "wrapper: td wraps tag in an td" do
+    Forme::Form.new(:wrapper=>:td).input(:textarea, :id=>'foo').to_s.should == '<td><textarea id="foo"></textarea></td>'
+    Forme::Form.new(:wrapper=>:td).input(:textarea, :id=>'foo', :wrapper_attr=>{:id=>'bar'}).to_s.should == '<td id="bar"><textarea id="foo"></textarea></td>'
   end
 
   specify "wrapper: trtd wraps tag in an tr/td" do
     Forme::Form.new(:wrapper=>:trtd).input(:textarea, :id=>'foo').to_s.should == '<tr><td><textarea id="foo"></textarea></td><td></td></tr>'
+    Forme::Form.new(:wrapper=>:trtd).input(:textarea, :id=>'foo', :wrapper_attr=>{:id=>'bar'}).to_s.should == '<tr id="bar"><td><textarea id="foo"></textarea></td><td></td></tr>'
   end
 
   specify "wrapper: trtd supports multiple tags in separate tds" do
@@ -499,12 +747,44 @@ describe "Forme built-in custom" do
     Forme::Form.new(:wrapper=>:trtd, :labeler=>:explicit).input(:checkbox, :id=>'foo', :name=>'foo', :label=>'Foo').to_s.should == '<tr><td><label for="foo">Foo</label></td><td><input id="foo_hidden" name="foo" type="hidden" value="0"/><input id="foo" name="foo" type="checkbox"/></td></tr>'
   end
 
+  specify "wrapper: tr should use a td wrapper and tr inputs_wrapper" do
+    Forme::Form.new(:wrapper=>:tr).inputs([:textarea]).to_s.should == '<tr><td><textarea></textarea></td></tr>'
+    f = Forme::Form.new
+    f.with_opts(:wrapper=>:tr){f.inputs([:textarea])}.to_s.should == '<tr><td><textarea></textarea></td></tr>'
+  end
+
+  specify "wrapper: table should use a trtd wrapper and table inputs_wrapper" do
+    Forme::Form.new(:wrapper=>:table).inputs([:textarea]).to_s.should == '<table><tr><td><textarea></textarea></td><td></td></tr></table>'
+    f = Forme::Form.new
+    f.with_opts(:wrapper=>:table){f.inputs([:textarea])}.to_s.should == '<table><tr><td><textarea></textarea></td><td></td></tr></table>'
+  end
+
+  specify "wrapper: ol should use an li wrapper and ol inputs_wrapper" do
+    Forme::Form.new(:wrapper=>:ol).inputs([:textarea]).to_s.should == '<ol><li><textarea></textarea></li></ol>'
+    f = Forme::Form.new
+    f.with_opts(:wrapper=>:ol){f.inputs([:textarea])}.to_s.should == '<ol><li><textarea></textarea></li></ol>'
+  end
+
+  specify "wrapper: fieldset_ol should use an li wrapper and fieldset_ol inputs_wrapper" do
+    Forme::Form.new(:wrapper=>:fieldset_ol).inputs([:textarea]).to_s.should == '<fieldset class="inputs"><ol><li><textarea></textarea></li></ol></fieldset>'
+    f = Forme::Form.new
+    f.with_opts(:wrapper=>:fieldset_ol){f.inputs([:textarea])}.to_s.should == '<fieldset class="inputs"><ol><li><textarea></textarea></li></ol></fieldset>'
+  end
+
+  specify "wrapper should not override inputs_wrapper if both given" do
+    Forme::Form.new(:wrapper=>:tr, :inputs_wrapper=>:div).inputs([:textarea]).to_s.should == '<div><td><textarea></textarea></td></div>'
+    f = Forme::Form.new
+    f.with_opts(:wrapper=>:tr, :inputs_wrapper=>:div){f.inputs([:textarea])}.to_s.should == '<div><td><textarea></textarea></td></div>'
+  end
+
   specify "inputs_wrapper: ol wraps tags in an ol" do
     Forme::Form.new(:inputs_wrapper=>:ol, :wrapper=>:li).inputs([:textarea]).to_s.should == '<ol><li><textarea></textarea></li></ol>'
+    Forme::Form.new(:inputs_wrapper=>:ol, :wrapper=>:li).inputs([:textarea], :attr=>{:foo=>1}).to_s.should == '<ol foo="1"><li><textarea></textarea></li></ol>'
   end
 
   specify "inputs_wrapper: fieldset_ol wraps tags in a fieldset and an ol" do
     Forme::Form.new(:inputs_wrapper=>:fieldset_ol, :wrapper=>:li).inputs([:textarea]).to_s.should == '<fieldset class="inputs"><ol><li><textarea></textarea></li></ol></fieldset>'
+    Forme::Form.new(:inputs_wrapper=>:fieldset_ol, :wrapper=>:li).inputs([:textarea], :attr=>{:foo=>1}).to_s.should == '<fieldset class="inputs" foo="1"><ol><li><textarea></textarea></li></ol></fieldset>'
   end
 
   specify "inputs_wrapper: fieldset_ol supports a :legend option" do
@@ -513,10 +793,33 @@ describe "Forme built-in custom" do
 
   specify "inputs_wrapper: div wraps tags in a div" do
     Forme::Form.new(:inputs_wrapper=>:div, :wrapper=>:span).inputs([:textarea]).to_s.should == '<div><span><textarea></textarea></span></div>'
+    Forme::Form.new(:inputs_wrapper=>:div, :wrapper=>:span).inputs([:textarea], :attr=>{:foo=>1}).to_s.should == '<div foo="1"><span><textarea></textarea></span></div>'
+  end
+
+  specify "inputs_wrapper: tr wraps tags in an tr" do
+    Forme::Form.new(:inputs_wrapper=>:tr, :wrapper=>:td).inputs([:textarea]).to_s.should == '<tr><td><textarea></textarea></td></tr>'
+    Forme::Form.new(:inputs_wrapper=>:tr, :wrapper=>:td).inputs([:textarea], :attr=>{:foo=>1}).to_s.should == '<tr foo="1"><td><textarea></textarea></td></tr>'
   end
 
   specify "inputs_wrapper: table wraps tags in an table" do
     Forme::Form.new(:inputs_wrapper=>:table, :wrapper=>:trtd).inputs([:textarea]).to_s.should == '<table><tr><td><textarea></textarea></td><td></td></tr></table>'
+    Forme::Form.new(:inputs_wrapper=>:table, :wrapper=>:trtd).inputs([:textarea], :attr=>{:foo=>1}).to_s.should == '<table foo="1"><tr><td><textarea></textarea></td><td></td></tr></table>'
+  end
+
+  specify "inputs_wrapper: table accepts a :legend option" do
+   Forme::Form.new(:inputs_wrapper=>:table, :wrapper=>:trtd).inputs([:textarea], :legend=>'Inputs').to_s.should == '<table><caption>Inputs</caption><tr><td><textarea></textarea></td><td></td></tr></table>'
+  end
+
+  specify "inputs_wrapper: table accepts a :legend_attr option" do
+    Forme::Form.new(:inputs_wrapper=>:table, :wrapper=>:trtd).inputs([:textarea], :legend=>'Inputs', :legend_attr=>{:class=>'foo'}).to_s.should == '<table><caption class="foo">Inputs</caption><tr><td><textarea></textarea></td><td></td></tr></table>'
+  end
+
+  specify "inputs_wrapper: table accepts a :labels option" do
+    Forme::Form.new(:inputs_wrapper=>:table).inputs(:labels=>%w'A B C').to_s.should == '<table><tr><th>A</th><th>B</th><th>C</th></tr></table>'
+  end
+
+  specify "inputs_wrapper: table doesn't add empty header row for :labels=>[]" do
+    Forme::Form.new(:inputs_wrapper=>:table).inputs(:labels=>[]).to_s.should == '<table></table>'
   end
 
   specify "serializer: html_usa formats dates and datetimes in American format without timezones" do
@@ -630,6 +933,14 @@ describe "Forme object forms" do
     Forme::Form.new([:foo]).input(:first, :attr=>{:x=>'bar'}).to_s.should ==  '<input id="first" name="first" type="text" value="foo" x="bar"/>'
   end
 
+  specify "should respect current namespace" do
+    Forme::Form.new([:foo], :namespace=>'a').input(:first).to_s.should ==  '<input id="a_first" name="a[first]" type="text" value="foo"/>'
+  end
+
+  specify "should get values for hashes using #[]" do
+    Forme::Form.new(:obj=>{:bar=>:foo}, :namespace=>'a').input(:bar).to_s.should ==  '<input id="a_bar" name="a[bar]" type="text" value="foo"/>'
+  end
+
   specify "should handle obj passed in via :obj hash key" do
     Forme::Form.new(:obj=>[:foo]).input(:first).to_s.should ==  '<input id="first" name="first" type="text" value="foo"/>'
   end