middleman 3.0.0.alpha.6 → 3.0.0.alpha.7

data/lib/middleman/vendor/padrino-helpers-0.10.5/test/fixtures/render_app/views/current_engine.haml

@@ -1,5 +0,0 @@
-%p.start= current_engine
-%p.haml= partial 'current_engines/haml'
-%p.erb= partial 'current_engines/erb'
-%p.slim= partial 'current_engines/slim'
-%p.end= current_engine

data/lib/middleman/vendor/padrino-helpers-0.10.5/test/fixtures/render_app/views/current_engines/_erb.erb

@@ -1 +0,0 @@
-<span><%= current_engine %></span>

data/lib/middleman/vendor/padrino-helpers-0.10.5/test/fixtures/render_app/views/current_engines/_haml.haml

@@ -1 +0,0 @@
-%span=current_engine

data/lib/middleman/vendor/padrino-helpers-0.10.5/test/fixtures/render_app/views/current_engines/_slim.slim

@@ -1 +0,0 @@
-span=current_engine

data/lib/middleman/vendor/padrino-helpers-0.10.5/test/fixtures/render_app/views/erb/test.erb

@@ -1 +0,0 @@
-<h1>This is a <%= @template %> template!</h1>

data/lib/middleman/vendor/padrino-helpers-0.10.5/test/fixtures/render_app/views/explicit_engine.haml

@@ -1,5 +0,0 @@
-%p.start= current_engine
-%p.haml= partial "current_engines/haml", :engine => :haml
-%p.erb= partial 'current_engines/erb', :engine => :erb
-%p.slim= partial 'current_engines/slim', :engine => :slim
-%p.end= current_engine

data/lib/middleman/vendor/padrino-helpers-0.10.5/test/fixtures/render_app/views/haml/test.haml

@@ -1 +0,0 @@
-%h1 This is a #{@template} template!

data/lib/middleman/vendor/padrino-helpers-0.10.5/test/fixtures/render_app/views/template/_user.haml

@@ -1,7 +0,0 @@
-%h1 User name is #{user.name}
-
-- if defined?(extra)
-  %p Extra is #{extra}
-
-- if defined?(user_counter)
-  %p My counter is #{user_counter}

data/lib/middleman/vendor/padrino-helpers-0.10.5/test/fixtures/render_app/views/template/haml_template.haml

@@ -1 +0,0 @@
-%h1 This is a #{@template} template sent from render_template!

data/lib/middleman/vendor/padrino-helpers-0.10.5/test/fixtures/render_app/views/template/some_template.haml

@@ -1,2 +0,0 @@
-
-%h1 This is a haml template which was detected!

data/lib/middleman/vendor/padrino-helpers-0.10.5/test/helper.rb

@@ -1,66 +0,0 @@
-require File.expand_path('../../../load_paths', __FILE__)
-require File.join(File.dirname(__FILE__), '..', '..', 'padrino-core', 'test', 'mini_shoulda')
-require 'rack/test'
-require 'webrat'
-require 'padrino-helpers'
-require 'active_support/time'
-
-class MiniTest::Spec
-  include Padrino::Helpers::OutputHelpers
-  include Padrino::Helpers::TagHelpers
-  include Padrino::Helpers::AssetTagHelpers
-  include Rack::Test::Methods
-  include Webrat::Methods
-  include Webrat::Matchers
-
-  Webrat.configure do |config|
-    config.mode = :rack
-  end
-
-  def stop_time_for_test
-    time = Time.now
-    Time.stubs(:now).returns(time)
-    return time
-  end
-
-  # assert_has_tag(:h1, :content => "yellow") { "<h1>yellow</h1>" }
-  # In this case, block is the html to evaluate
-  def assert_has_tag(name, attributes = {}, &block)
-    html = block && block.call
-    matcher = HaveSelector.new(name, attributes)
-    raise "Please specify a block!" if html.blank?
-    assert matcher.matches?(html), matcher.failure_message
-  end
-
-  # assert_has_no_tag, tag(:h1, :content => "yellow") { "<h1>green</h1>" }
-  # In this case, block is the html to evaluate
-  def assert_has_no_tag(name, attributes = {}, &block)
-    html = block && block.call
-    attributes.merge!(:count => 0)
-    matcher = HaveSelector.new(name, attributes)
-    raise "Please specify a block!" if html.blank?
-    assert matcher.matches?(html), matcher.failure_message
-  end
-
-  # Asserts that a file matches the pattern
-  def assert_match_in_file(pattern, file)
-    assert File.exist?(file), "File '#{file}' does not exist!"
-    assert_match pattern, File.read(file)
-  end
-
-  # mock_model("Business", :new_record? => true) => <Business>
-  def mock_model(klazz, options={})
-    options.reverse_merge!(:class => klazz, :new_record? => false, :id => 20, :errors => {})
-    record = stub(options)
-    record.stubs(:to_ary => [record])
-    record
-  end
-end
-
-module Webrat
-  module Logging
-    def logger # @private
-      @logger = nil
-    end
-  end
-end

data/lib/middleman/vendor/padrino-helpers-0.10.5/test/test_asset_tag_helpers.rb

@@ -1,320 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
-require File.expand_path(File.dirname(__FILE__) + '/fixtures/markup_app/app')
-
-describe "AssetTagHelpers" do
-  include Padrino::Helpers::AssetTagHelpers
-
-  def app
-    MarkupDemo.tap { |app| app.set :environment, :test }
-  end
-
-  def flash
-    { :notice => "Demo notice" }
-  end
-
-  context 'for #flash_tag method' do
-    should "display flash with no given attributes" do
-      assert_has_tag('div.notice', :content => "Demo notice") { flash_tag(:notice) }
-    end
-    should "display flash with given attributes" do
-      actual_html = flash_tag(:notice, :class => 'notice', :id => 'notice-area')
-      assert_has_tag('div.notice#notice-area', :content => "Demo notice") { actual_html }
-    end
-  end
-
-  context 'for #link_to method' do
-    should "display link element with no given attributes" do
-      assert_has_tag('a', :content => "Sign up", :href => '/register') { link_to('Sign up', '/register') }
-    end
-
-    should "display link element with given attributes" do
-      actual_html = link_to('Sign up', '/register', :class => 'first', :id => 'linky')
-      assert_has_tag('a#linky.first', :content => "Sign up", :href => '/register') { actual_html }
-    end
-
-    should "display link element with anchor attribute" do
-      actual_html = link_to("Anchor", "/anchor", :anchor => :foo)
-      assert_has_tag('a', :content => "Anchor", :href => '/anchor#foo') { actual_html }
-    end
-
-    should "display link element with void url and options" do
-      actual_link = link_to('Sign up', :class => "test")
-      assert_has_tag('a', :content => "Sign up", :href => 'javascript:void(0);', :class => 'test') { actual_link }
-    end
-
-    should "display link element with remote option" do
-      actual_link = link_to('Sign up', '/register', :remote => true)
-      assert_has_tag('a', :content => "Sign up", :href => '/register', 'data-remote' => 'true') { actual_link }
-    end
-
-    should "display link element with method option" do
-      actual_link = link_to('Sign up', '/register', :method => :delete)
-      assert_has_tag('a', :content => "Sign up", :href => '/register', 'data-method' => 'delete', :rel => 'nofollow') { actual_link }
-    end
-
-    should "display link element with confirm option" do
-      actual_link = link_to('Sign up', '/register', :confirm => "Are you sure?")
-      assert_has_tag('a', :content => "Sign up", :href => '/register', 'data-confirm' => 'Are you sure?') { actual_link }
-    end
-
-    should "display link element with ruby block" do
-      actual_link = link_to('/register', :class => 'first', :id => 'binky') { "Sign up" }
-      assert_has_tag('a#binky.first', :content => "Sign up", :href => '/register') { actual_link }
-    end
-
-    should "display link block element in haml" do
-      visit '/haml/link_to'
-      assert_have_selector :a, :content => "Test 1 No Block", :href => '/test1', :class => 'test', :id => 'test1'
-      assert_have_selector :a, :content => "Test 2 With Block", :href => '/test2', :class => 'test', :id => 'test2'
-    end
-
-    should "display link block element in erb" do
-      visit '/erb/link_to'
-      assert_have_selector :a, :content => "Test 1 No Block", :href => '/test1', :class => 'test', :id => 'test1'
-      assert_have_selector :a, :content => "Test 2 With Block", :href => '/test2', :class => 'test', :id => 'test2'
-    end
-  end
-
-  context 'for #mail_to method' do
-    should "display link element for mail to no caption" do
-      actual_html = mail_to('test@demo.com')
-      assert_has_tag(:a, :href => "mailto:test@demo.com", :content => 'test@demo.com') { actual_html }
-    end
-
-    should "display link element for mail to with caption" do
-      actual_html = mail_to('test@demo.com', "My Email", :class => 'demo')
-      assert_has_tag(:a, :href => "mailto:test@demo.com", :content => 'My Email', :class => 'demo') { actual_html }
-    end
-
-    should "display link element for mail to with caption and mail options" do
-      actual_html = mail_to('test@demo.com', "My Email", :subject => 'demo test', :class => 'demo', :cc => 'foo@test.com')
-      assert_has_tag(:a, :class => 'demo') { actual_html }
-      assert_match %r{mailto\:test\@demo.com\?}, actual_html
-      assert_match %r{cc=foo\@test\.com}, actual_html
-      assert_match %r{subject\=demo\%20test}, actual_html
-    end
-
-    should "display mail link element in haml" do
-      visit '/haml/mail_to'
-      assert_have_selector 'p.simple a', :href => 'mailto:test@demo.com', :content => 'test@demo.com'
-      assert_have_selector 'p.captioned a', :href => 'mailto:test@demo.com', :content => 'Click my Email'
-    end
-
-    should "display mail link element in erb" do
-      visit '/erb/mail_to'
-      assert_have_selector 'p.simple a', :href => 'mailto:test@demo.com', :content => 'test@demo.com'
-      assert_have_selector 'p.captioned a', :href => 'mailto:test@demo.com', :content => 'Click my Email'
-    end
-
-    should "display mail link element in slim" do
-      visit '/slim/mail_to'
-      assert_have_selector 'p.simple a', :href => 'mailto:test@demo.com', :content => 'test@demo.com'
-      assert_have_selector 'p.captioned a', :href => 'mailto:test@demo.com', :content => 'Click my Email'
-    end
-  end
-
-  context 'for #meta_tag method' do
-    should "display meta tag with given content and name" do
-      actual_html = meta_tag("weblog,news", :name => "keywords")
-      assert_has_tag("meta", :name => "keywords", "content" => "weblog,news") { actual_html }
-    end
-
-    should "display meta tag with given content and http-equiv" do
-      actual_html = meta_tag("text/html; charset=UTF-8", :"http-equiv" => "Content-Type")
-      assert_has_tag("meta", :"http-equiv" => "Content-Type", "content" => "text/html; charset=UTF-8") { actual_html }
-    end
-
-    should "display meta tag element in haml" do
-      visit '/haml/meta_tag'
-      assert_have_selector 'meta', "content" => "weblog,news", :name => "keywords"
-      assert_have_selector 'meta', "content" => "text/html; charset=UTF-8", :"http-equiv" => "Content-Type"
-    end
-
-    should "display meta tag element in erb" do
-      visit '/erb/meta_tag'
-      assert_have_selector 'meta', "content" => "weblog,news", :name => "keywords"
-      assert_have_selector 'meta', "content" => "text/html; charset=UTF-8", :"http-equiv" => "Content-Type"
-    end
-
-    should "display meta tag element in slim" do
-      visit '/slim/meta_tag'
-      assert_have_selector 'meta', "content" => "weblog,news", :name => "keywords"
-      assert_have_selector 'meta', "content" => "text/html; charset=UTF-8", :"http-equiv" => "Content-Type"
-    end
-  end
-
-  context 'for #image_tag method' do
-    should "display image tag absolute link with no options" do
-      time = stop_time_for_test
-      assert_has_tag('img', :src => "/absolute/pic.gif?#{time.to_i}") { image_tag('/absolute/pic.gif') }
-    end
-
-    should "display image tag absolute link with specified uri root" do
-      time = stop_time_for_test
-      self.class.stubs(:uri_root).returns("/blog")
-      assert_has_tag('img', :src => "/blog/images/relative/pic.gif?#{time.to_i}") { image_tag('relative/pic.gif') }
-    end
-
-    should "display image tag relative link with options" do
-      time = stop_time_for_test
-      assert_has_tag('img.photo', :src => "/images/relative/pic.gif?#{time.to_i}") {
-        image_tag('relative/pic.gif', :class => 'photo') }
-    end
-
-    should "display image tag uri link with options" do
-      time = stop_time_for_test
-      assert_has_tag('img.photo', :src => "http://demo.org/pic.gif") { image_tag('http://demo.org/pic.gif', :class => 'photo') }
-    end
-
-    should "display image tag relative link with incorrect spacing" do
-      time = stop_time_for_test
-      assert_has_tag('img.photo', :src => "/images/%20relative/%20pic.gif%20%20?#{time.to_i}") {
-        image_tag(' relative/ pic.gif  ', :class => 'photo') }
-    end
-
-    should "not use a timestamp if stamp setting is false" do
-      self.class.expects(:asset_stamp).returns(false)
-      assert_has_tag('img', :src => "/absolute/pic.gif") { image_tag('/absolute/pic.gif') }
-    end
-
-    should "have xhtml convention tag" do
-      self.class.expects(:asset_stamp).returns(false)
-      assert_equal image_tag('/absolute/pic.gif'), '<img src="/absolute/pic.gif" />'
-    end
-  end
-
-  context 'for #stylesheet_link_tag method' do
-    should "display stylesheet link item" do
-      time = stop_time_for_test
-      expected_options = { :media => "screen", :rel => "stylesheet", :type => "text/css" }
-      assert_has_tag('link', expected_options.merge(:href => "/stylesheets/style.css?#{time.to_i}")) { stylesheet_link_tag('style') }
-    end
-
-    should "display stylesheet link item for long relative path" do
-      time = stop_time_for_test
-      expected_options = { :media => "screen", :rel => "stylesheet", :type => "text/css" }
-      actual_html = stylesheet_link_tag('example/demo/style')
-      assert_has_tag('link', expected_options.merge(:href => "/stylesheets/example/demo/style.css?#{time.to_i}")) { actual_html }
-    end
-
-    should "display stylesheet link item with absolute path" do
-      time = stop_time_for_test
-      expected_options = { :media => "screen", :rel => "stylesheet", :type => "text/css" }
-      actual_html = stylesheet_link_tag('/css/style')
-      assert_has_tag('link', expected_options.merge(:href => "/css/style.css?#{time.to_i}")) { actual_html }
-    end
-
-    should "display stylesheet link item with uri root" do
-      self.class.stubs(:uri_root).returns("/blog")
-      time = stop_time_for_test
-      expected_options = { :media => "screen", :rel => "stylesheet", :type => "text/css" }
-      actual_html = stylesheet_link_tag('style')
-      assert_has_tag('link', expected_options.merge(:href => "/blog/stylesheets/style.css?#{time.to_i}")) { actual_html }
-    end
-
-    should "display stylesheet link items" do
-      time = stop_time_for_test
-      actual_html = stylesheet_link_tag('style', 'layout.css', 'http://google.com/style.css')
-      assert_has_tag('link', :media => "screen", :rel => "stylesheet", :type => "text/css", :count => 3) { actual_html }
-      assert_has_tag('link', :href => "/stylesheets/style.css?#{time.to_i}") { actual_html }
-      assert_has_tag('link', :href => "/stylesheets/layout.css?#{time.to_i}") { actual_html }
-      assert_has_tag('link', :href => "http://google.com/style.css") { actual_html }
-      assert_equal actual_html, stylesheet_link_tag(['style', 'layout.css', 'http://google.com/style.css'])
-    end
-
-    should "not use a timestamp if stamp setting is false" do
-      self.class.expects(:asset_stamp).returns(false)
-      expected_options = { :media => "screen", :rel => "stylesheet", :type => "text/css" }
-      assert_has_tag('link', expected_options.merge(:href => "/stylesheets/style.css")) { stylesheet_link_tag('style') }
-    end
-  end
-
-  context 'for #javascript_include_tag method' do
-    should "display javascript item" do
-      time = stop_time_for_test
-      actual_html = javascript_include_tag('application')
-      assert_has_tag('script', :src => "/javascripts/application.js?#{time.to_i}", :type => "text/javascript") { actual_html }
-    end
-
-    should "display javascript item for long relative path" do
-      time = stop_time_for_test
-      actual_html = javascript_include_tag('example/demo/application')
-      assert_has_tag('script', :src => "/javascripts/example/demo/application.js?#{time.to_i}", :type => "text/javascript") { actual_html }
-    end
-
-    should "display javascript item for path containing js" do
-      time = stop_time_for_test
-      actual_html = javascript_include_tag 'test/jquery.json'
-      assert_has_tag('script', :src => "/javascripts/test/jquery.json?#{time.to_i}", :type => "text/javascript") { actual_html }
-    end
-
-    should "display javascript item for path containing period" do
-      time = stop_time_for_test
-      actual_html = javascript_include_tag 'test/jquery.min'
-      assert_has_tag('script', :src => "/javascripts/test/jquery.min.js?#{time.to_i}", :type => "text/javascript") { actual_html }
-    end
-
-    should "display javascript item with absolute path" do
-      time = stop_time_for_test
-      actual_html = javascript_include_tag('/js/application')
-      assert_has_tag('script', :src => "/js/application.js?#{time.to_i}", :type => "text/javascript") { actual_html }
-    end
-
-    should "display javascript item with uri root" do
-      self.class.stubs(:uri_root).returns("/blog")
-      time = stop_time_for_test
-      actual_html = javascript_include_tag('application')
-      assert_has_tag('script', :src => "/blog/javascripts/application.js?#{time.to_i}", :type => "text/javascript") { actual_html }
-    end
-
-    should "display javascript items" do
-      time = stop_time_for_test
-      actual_html = javascript_include_tag('application', 'base.js', 'http://google.com/lib.js')
-      assert_has_tag('script', :type => "text/javascript", :count => 3) { actual_html }
-      assert_has_tag('script', :src => "/javascripts/application.js?#{time.to_i}") { actual_html }
-      assert_has_tag('script', :src => "/javascripts/base.js?#{time.to_i}") { actual_html }
-      assert_has_tag('script', :src => "http://google.com/lib.js") { actual_html }
-      assert_equal actual_html, javascript_include_tag(['application', 'base.js', 'http://google.com/lib.js'])
-    end
-
-    should "not use a timestamp if stamp setting is false" do
-      self.class.expects(:asset_stamp).returns(false)
-      actual_html = javascript_include_tag('application')
-      assert_has_tag('script', :src => "/javascripts/application.js", :type => "text/javascript") { actual_html }
-    end
-  end
-
-  context "for #favicon_tag method" do
-    should "display favicon" do
-      time = stop_time_for_test
-      actual_html = favicon_tag('icons/favicon.png')
-      assert_has_tag('link', :rel => 'icon', :type => 'image/png', :href => "/images/icons/favicon.png?#{time.to_i}") { actual_html }
-    end
-
-    should "match type with file ext" do
-      time = stop_time_for_test
-      actual_html = favicon_tag('favicon.ico')
-      assert_has_tag('link', :rel => 'icon', :type => 'image/ico', :href => "/images/favicon.ico?#{time.to_i}") { actual_html }
-    end
-
-    should "allow option overrides" do
-      time = stop_time_for_test
-      actual_html = favicon_tag('favicon.png', :type => 'image/ico')
-      assert_has_tag('link', :rel => 'icon', :type => 'image/ico', :href => "/images/favicon.png?#{time.to_i}") { actual_html }
-    end
-  end
-
-  context 'for #feed_tag method' do
-    should "generate correctly link tag for rss" do
-      assert_has_tag('link', :type => 'application/rss+xml', :rel => 'alternate', :href => "/blog/post.rss", :title => 'rss') { feed_tag :rss, "/blog/post.rss" }
-    end
-
-    should "generate correctly link tag for atom" do
-      assert_has_tag('link', :type => 'application/atom+xml', :rel => 'alternate', :href => "/blog/post.atom", :title => 'atom') { feed_tag :atom, "/blog/post.atom" }
-    end
-
-    should "override options" do
-      assert_has_tag('link', :type => 'my-type', :rel => 'my-rel', :href => "/blog/post.rss", :title => 'my-title') { feed_tag :rss, "/blog/post.rss", :type => "my-type", :rel => "my-rel", :title => "my-title" }
-    end
-  end
-end

data/lib/middleman/vendor/padrino-helpers-0.10.5/test/test_form_builder.rb

@@ -1,996 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
-require File.expand_path(File.dirname(__FILE__) + '/fixtures/markup_app/app')
-
-describe "FormBuilder" do
-  include Padrino::Helpers::FormHelpers
-
-  # Dummy form builder for testing
-  module Padrino::Helpers::FormBuilder
-    class FakeFormBuilder < AbstractFormBuilder
-      def foo_field; @template.content_tag(:span, "bar"); end
-    end
-  end
-
-  def app
-    MarkupDemo.tap { |app| app.set :environment, :test }
-  end
-
-  def setup
-    role_types = [mock_model('Role', :name => "Admin", :id => 1),
-      mock_model('Role', :name => 'Moderate', :id => 2),  mock_model('Role', :name => 'Limited', :id => 3)]
-    @user = mock_model("User", :first_name => "Joe", :email => '', :session_id => 54)
-    @user.stubs(:errors => {:a => "must be present", :b => "must be valid", :email => "Must be valid", :first_name => []})
-    @user.stubs(:role_types => role_types, :role => "1")
-    @user_none = mock_model("User")
-  end
-
-  def standard_builder(object=@user)
-    Padrino::Helpers::FormBuilder::StandardFormBuilder.new(self, object)
-  end
-
-  context 'for #form_for method' do
-    should "display correct form html" do
-      actual_html = form_for(@user, '/register', :id => 'register', :"accept-charset" => "UTF-8", :method => 'post') { "Demo" }
-      assert_has_tag('form', :"accept-charset" => "UTF-8", :action => '/register', :id => 'register', :method => 'post', :content => "Demo") { actual_html }
-      assert_has_tag('form input[type=hidden]', :name => '_method', :count => 0) { actual_html } # no method action field
-    end
-
-    should "display correct form html with fake object" do
-      actual_html = form_for(:markup_user, '/register', :id => 'register', :"accept-charset" => "UTF-8", :method => 'post') { |f| f.text_field :username }
-      assert_has_tag('form', :"accept-charset" => "UTF-8", :action => '/register', :id => 'register', :method => 'post') { actual_html }
-      assert_has_tag('form input', :type => 'text', :name => 'markup_user[username]') { actual_html }
-      assert_has_tag('form input[type=hidden]', :name => '_method', :count => 0) { actual_html } # no method action field
-    end
-
-    should "display correct form html for namespaced object" do
-      actual_html = form_for(Outer::UserAccount.new, '/register', :"accept-charset" => "UTF-8", :method => 'post') { |f| f.text_field :username }
-      assert_has_tag('form', :"accept-charset" => "UTF-8", :action => '/register', :method => 'post') { actual_html }
-      assert_has_tag('form input', :type => 'text', :name => 'outer_user_account[username]') { actual_html }
-    end
-
-    should "display form specifying default builder setting" do
-      self.expects(:settings).returns(stub(:default_builder => 'FakeFormBuilder')).once
-      actual_html = ""
-      actual_html = form_for(@user, '/register', :id => 'register', :"accept-charset" => "UTF-8", :method => 'post') { |f| f.foo_field }
-      assert_has_tag('form', :"accept-charset" => "UTF-8", :action => '/register', :method => 'post') { actual_html }
-      assert_has_tag('span', :content => "bar") { actual_html }
-    end
-
-    should "display correct form html with remote option" do
-      actual_html = form_for(@user, '/update', :"accept-charset" => "UTF-8", :remote => true) { "Demo" }
-      assert_has_tag('form', :"accept-charset" => "UTF-8", :action => '/update', :method => 'post', "data-remote" => 'true') { actual_html }
-    end
-
-    should "display correct form html with remote option and method put" do
-      actual_html = form_for(@user, '/update', :"accept-charset" => "UTF-8", :remote => true, :method => 'put') { "Demo" }
-      assert_has_tag('form', :"accept-charset" => "UTF-8", :method => 'post', "data-method" => 'put', "data-remote" => 'true') { actual_html }
-      assert_has_tag('form input', :type => 'hidden', :name => "_method", :value => 'put') { actual_html }
-    end
-
-    should "display correct form html with method :put" do
-      actual_html = form_for(@user, '/update', :"accept-charset" => "UTF-8", :method => 'put') { "Demo" }
-      assert_has_tag('form', :"accept-charset" => "UTF-8", :action => '/update', :method => 'post') { actual_html }
-      assert_has_tag('form input', :type => 'hidden', :name => "_method", :value => 'put') { actual_html }
-    end
-
-    should "display correct form html with method :delete" do
-      actual_html = form_for(@user, '/destroy', :"accept-charset" => "UTF-8", :method => 'delete') { "Demo" }
-      assert_has_tag('form', :"accept-charset" => "UTF-8", :action => '/destroy', :method => 'post') { actual_html }
-      assert_has_tag('form input', :type => 'hidden', :name => "_method", :value => 'delete') { actual_html }
-    end
-
-    should "display correct form html with multipart" do
-      actual_html = form_for(@user, '/register', :"accept-charset" => "UTF-8", :multipart => true) { "Demo" }
-      assert_has_tag('form', :"accept-charset" => "UTF-8", :action => '/register', :enctype => "multipart/form-data") { actual_html }
-    end
-
-    should "support changing form builder type" do
-      form_html = proc { form_for(@user, '/register', :"accept-charset" => "UTF-8", :builder => "AbstractFormBuilder") { |f| f.text_field_block(:name) } }
-      assert_raises(NoMethodError) { form_html.call }
-    end
-
-    should "support using default standard builder" do
-      actual_html = form_for(@user, '/register') { |f| f.text_field_block(:name) }
-      assert_has_tag('form p input[type=text]') { actual_html }
-    end
-
-    should "display fail for form with nil object" do
-      assert_raises(RuntimeError) { form_for(@not_real, '/register', :id => 'register', :method => 'post') { "Demo" } }
-    end
-
-    should "display correct form in haml" do
-      visit '/haml/form_for'
-      assert_have_selector :form, :action => '/demo', :id => 'demo'
-      assert_have_selector :form, :action => '/another_demo', :id => 'demo2', :method => 'get'
-      assert_have_selector :form, :action => '/third_demo', :id => 'demo3', :method => 'get'
-    end
-
-    should "display correct form in erb" do
-      visit '/erb/form_for'
-      assert_have_selector :form, :action => '/demo', :id => 'demo'
-      assert_have_selector :form, :action => '/another_demo', :id => 'demo2', :method => 'get'
-      assert_have_selector :form, :action => '/third_demo', :id => 'demo3', :method => 'get'
-    end
-
-    should "display correct form in slim" do
-      visit '/slim/form_for'
-      assert_have_selector :form, :action => '/demo', :id => 'demo'
-      assert_have_selector :form, :action => '/another_demo', :id => 'demo2', :method => 'get'
-      assert_have_selector :form, :action => '/third_demo', :id => 'demo3', :method => 'get'
-    end
-
-    should "have a class of 'invalid' for fields with errors" do
-      actual_html = form_for(@user, '/register') {|f| f.text_field(:email) }
-      assert_has_tag(:input, :type => 'text', :name => 'user[email]', :id => 'user_email', :class => 'invalid') {actual_html }
-    end
-
-    should "not have a class of 'invalid' for fields with no errors" do
-      actual_html = form_for(@user, '/register') {|f| f.text_field(:first_name) }
-      assert_has_no_tag(:input, :type => 'text', :name => 'user[first_name]', :id => 'user_first_name', :class => 'invalid') {actual_html }
-    end
-  end
-
-  context 'for #fields_for method' do
-    should 'display correct fields html' do
-      actual_html = fields_for(@user) { |f| f.text_field(:first_name) }
-      assert_has_tag(:input, :type => 'text', :name => 'user[first_name]', :id => 'user_first_name') { actual_html }
-    end
-
-    should 'display correct fields html with symbol object' do
-      actual_html = fields_for(:markup_user) { |f| f.text_field(:first_name) }
-      assert_has_tag(:input, :type => 'text', :name => 'markup_user[first_name]', :id => 'markup_user_first_name') { actual_html }
-    end
-
-    should "display fail for nil object" do
-      assert_raises(RuntimeError) { fields_for(@not_real) { |f| "Demo" } }
-    end
-
-    should 'display correct simple fields in haml' do
-      visit '/haml/fields_for'
-      assert_have_selector :form, :action => '/demo1', :id => 'demo-fields-for'
-      assert_have_selector '#demo-fields-for input', :type => 'text', :name => 'markup_user[gender]', :value => 'male'
-      assert_have_selector '#demo-fields-for input', :type => 'checkbox', :name => 'permission[can_edit]', :value => '1', :checked => 'checked'
-      assert_have_selector '#demo-fields-for input', :type => 'checkbox', :name => 'permission[can_delete]'
-    end
-
-    should "display correct simple fields in erb" do
-      visit '/erb/fields_for'
-      assert_have_selector :form, :action => '/demo1', :id => 'demo-fields-for'
-      assert_have_selector '#demo-fields-for input', :type => 'text', :name => 'markup_user[gender]', :value => 'male'
-      assert_have_selector '#demo-fields-for input', :type => 'checkbox', :name => 'permission[can_edit]', :value => '1', :checked => 'checked'
-      assert_have_selector '#demo-fields-for input', :type => 'checkbox', :name => 'permission[can_delete]'
-    end
-
-    should "display correct simple fields in slim" do
-      visit '/slim/fields_for'
-      assert_have_selector :form, :action => '/demo1', :id => 'demo-fields-for'
-      assert_have_selector '#demo-fields-for input', :type => 'text', :name => 'markup_user[gender]', :value => 'male'
-      assert_have_selector '#demo-fields-for input', :type => 'checkbox', :name => 'permission[can_edit]', :value => '1', :checked => 'checked'
-      assert_have_selector '#demo-fields-for input', :type => 'checkbox', :name => 'permission[can_delete]'
-    end
-  end
-
-  # ===========================
-  # AbstractFormBuilder
-  # ===========================
-
-  context 'for #error_messages method' do
-    should "display correct form html with no record" do
-      actual_html = standard_builder(@user_none).error_messages(:header_message => "Demo form cannot be saved")
-      assert actual_html.blank?
-    end
-
-    should "display correct form html with valid record" do
-      actual_html = standard_builder.error_messages(:header_message => "Demo form cannot be saved", :style => "foo:bar", :class => "mine")
-      assert_has_tag('#field-errors h2', :content => "Demo form cannot be saved") { actual_html }
-      assert_has_tag('#field-errors ul li', :content => "B must be valid") { actual_html }
-      assert_has_tag('#field-errors ul li', :content => "A must be present") { actual_html }
-      assert_has_tag('#field-errors', :style => "foo:bar") { actual_html }
-      assert_has_tag('#field-errors', :class => "mine") { actual_html }
-    end
-
-    should "display correct form in haml" do
-      visit '/haml/form_for'
-      assert_have_selector '#demo div.field-errors h2',     :content => "custom MarkupUser cannot be saved!"
-      assert_have_selector '#demo div.field-errors ul li',  :content => "Fake must be valid"
-      assert_have_selector '#demo div.field-errors ul li',  :content => "Second must be present"
-      assert_have_selector '#demo div.field-errors ul li',  :content => "Third must be a number"
-      assert_have_selector '#demo2 div.field-errors h2',    :content => "custom MarkupUser cannot be saved!"
-      assert_have_selector '#demo2 div.field-errors ul li', :content => "Fake must be valid"
-      assert_have_selector '#demo2 div.field-errors ul li', :content => "Second must be present"
-      assert_have_selector '#demo2 div.field-errors ul li', :content => "Third must be a number"
-      assert_have_selector '#demo input', :name => 'markup_user[email]', :class => 'invalid'
-    end
-
-    should "display correct form in erb" do
-      visit '/erb/form_for'
-      assert_have_selector '#demo div.field-errors h2',     :content => "custom MarkupUser cannot be saved!"
-      assert_have_selector '#demo div.field-errors ul li',  :content => "Fake must be valid"
-      assert_have_selector '#demo div.field-errors ul li',  :content => "Second must be present"
-      assert_have_selector '#demo div.field-errors ul li',  :content => "Third must be a number"
-      assert_have_selector '#demo2 div.field-errors h2',    :content => "custom MarkupUser cannot be saved!"
-      assert_have_selector '#demo2 div.field-errors ul li', :content => "Fake must be valid"
-      assert_have_selector '#demo2 div.field-errors ul li', :content => "Second must be present"
-      assert_have_selector '#demo2 div.field-errors ul li', :content => "Third must be a number"
-      assert_have_selector '#demo input', :name => 'markup_user[email]', :class => 'invalid'
-    end
-
-    should "display correct form in slim" do
-      visit '/slim/form_for'
-      assert_have_selector '#demo div.field-errors h2',     :content => "custom MarkupUser cannot be saved!"
-      assert_have_selector '#demo div.field-errors ul li',  :content => "Fake must be valid"
-      assert_have_selector '#demo div.field-errors ul li',  :content => "Second must be present"
-      assert_have_selector '#demo div.field-errors ul li',  :content => "Third must be a number"
-      assert_have_selector '#demo2 div.field-errors h2',    :content => "custom MarkupUser cannot be saved!"
-      assert_have_selector '#demo2 div.field-errors ul li', :content => "Fake must be valid"
-      assert_have_selector '#demo2 div.field-errors ul li', :content => "Second must be present"
-      assert_have_selector '#demo2 div.field-errors ul li', :content => "Third must be a number"
-      assert_have_selector '#demo input', :name => 'markup_user[email]', :class => 'invalid'
-    end
-  end
-
-  context 'for #error_message_on method' do
-    should "display correct form html with no record" do
-      actual_html = standard_builder(@user_none).error_message_on(:name)
-      assert actual_html.blank?
-    end
-
-    should "display error for specified invalid object" do
-      actual_html = standard_builder(@user).error_message_on(:a, :prepend => "foo", :append => "bar")
-      assert_has_tag('span.error', :content => "foo must be present bar") { actual_html }
-    end
-
-    should "display error for specified invalid object not matching class name" do
-      @bob = mock_model("User", :first_name => "Frank", :errors => { :foo => "must be bob" })
-      actual_html = standard_builder(@bob).error_message_on(:foo, :prepend => "foo", :append => "bar")
-      assert_has_tag('span.error', :content => "foo must be bob bar") { actual_html }
-    end
-  end
-
-  context 'for #label method' do
-    should "display correct label html" do
-      actual_html = standard_builder.label(:first_name, :class => 'large', :caption => "F. Name: ")
-      assert_has_tag('label', :class => 'large', :for => 'user_first_name', :content => "F. Name: ") { actual_html }
-    end
-
-    should "display correct label in haml" do
-      visit '/haml/form_for'
-      assert_have_selector '#demo label', :content => "Login: ", :class => 'user-label'
-      assert_have_selector '#demo label', :content => "About Me: "
-      assert_have_selector '#demo2 label', :content => "Nickname: ", :class => 'label'
-    end
-
-    should "display correct label in erb" do
-      visit '/erb/form_for'
-      assert_have_selector '#demo label', :content => "Login: ", :class => 'user-label'
-      assert_have_selector '#demo label', :content => "About Me: "
-      assert_have_selector '#demo2 label', :content => "Nickname: ", :class => 'label'
-    end
-
-    should "display correct label in slim" do
-      visit '/slim/form_for'
-      assert_have_selector '#demo label', :content => "Login: ", :class => 'user-label'
-      assert_have_selector '#demo label', :content => "About Me: "
-      assert_have_selector '#demo2 label', :content => "Nickname: ", :class => 'label'
-    end
-  end
-
-  context 'for #hidden_field method' do
-    should "display correct hidden field html" do
-      actual_html = standard_builder.hidden_field(:session_id, :class => 'hidden')
-      assert_has_tag('input.hidden[type=hidden]', :value => "54", :id => 'user_session_id', :name => 'user[session_id]') { actual_html }
-    end
-
-    should "display correct hidden field in haml" do
-      visit '/haml/form_for'
-      assert_have_selector '#demo input[type=hidden]', :id => 'markup_user_session_id', :value => "45"
-      assert_have_selector '#demo2 input', :type => 'hidden', :name => 'markup_user[session_id]'
-    end
-
-    should "display correct hidden field in erb" do
-      visit '/erb/form_for'
-      assert_have_selector '#demo input[type=hidden]', :id => 'markup_user_session_id', :value => "45"
-      assert_have_selector '#demo2 input', :type => 'hidden', :name => 'markup_user[session_id]'
-    end
-
-    should "display correct hidden field in slim" do
-      visit '/slim/form_for'
-      assert_have_selector '#demo input[type=hidden]', :id => 'markup_user_session_id', :value => "45"
-      assert_have_selector '#demo2 input', :type => 'hidden', :name => 'markup_user[session_id]'
-    end
-  end
-
-  context 'for #text_field method' do
-    should "display correct text field html" do
-      actual_html = standard_builder.text_field(:first_name, :class => 'large')
-      assert_has_tag('input.large[type=text]', :value => "Joe", :id => 'user_first_name', :name => 'user[first_name]') { actual_html }
-    end
-
-    should "display correct text field in haml" do
-      visit '/haml/form_for'
-      assert_have_selector '#demo input.user-text[type=text]', :id => 'markup_user_username', :value => "John"
-      assert_have_selector '#demo2 input', :type => 'text', :class => 'input', :name => 'markup_user[username]'
-    end
-
-    should "display correct text field in erb" do
-      visit '/erb/form_for'
-      assert_have_selector '#demo input.user-text[type=text]', :id => 'markup_user_username', :value => "John"
-      assert_have_selector '#demo2 input', :type => 'text', :class => 'input', :name => 'markup_user[username]'
-    end
-
-    should "display correct text field in slim" do
-      visit '/slim/form_for'
-      assert_have_selector '#demo input.user-text[type=text]', :id => 'markup_user_username', :value => "John"
-      assert_have_selector '#demo2 input', :type => 'text', :class => 'input', :name => 'markup_user[username]'
-    end
-  end
-
-  context 'for #check_box method' do
-    should "display correct checkbox html" do
-      actual_html = standard_builder.check_box(:confirm_destroy, :class => 'large')
-      assert_has_tag('input.large[type=checkbox]', :id => 'user_confirm_destroy', :name => 'user[confirm_destroy]') { actual_html }
-      assert_has_tag('input[type=hidden]', :name => 'user[confirm_destroy]', :value => '0') { actual_html }
-    end
-
-    should "display correct checkbox html when checked" do
-      actual_html = standard_builder.check_box(:confirm_destroy, :checked => true)
-      assert_has_tag('input[type=checkbox]', :checked => 'checked', :name => 'user[confirm_destroy]') { actual_html }
-    end
-
-    should "display correct checkbox html as checked when object value matches" do
-      @user.stubs(:show_favorites => 'human')
-      actual_html = standard_builder.check_box(:show_favorites, :value => 'human')
-      assert_has_tag('input[type=checkbox]', :checked => 'checked', :name => 'user[show_favorites]') { actual_html }
-    end
-
-    should "display correct checkbox html as checked when object value is true" do
-      @user.stubs(:show_favorites => true)
-      actual_html = standard_builder.check_box(:show_favorites, :value => '1')
-      assert_has_tag('input[type=checkbox]', :checked => 'checked', :name => 'user[show_favorites]') { actual_html }
-    end
-
-    should "display correct checkbox html as unchecked when object value doesn't match" do
-      @user.stubs(:show_favorites => 'alien')
-      actual_html = standard_builder.check_box(:show_favorites, :value => 'human')
-      assert_has_no_tag('input[type=checkbox]', :checked => 'checked') { actual_html }
-    end
-
-    should "display correct checkbox html as unchecked when object value is false" do
-      @user.stubs(:show_favorites => false)
-      actual_html = standard_builder.check_box(:show_favorites, :value => '1')
-      assert_has_no_tag('input[type=checkbox]', :checked => 'checked') { actual_html }
-    end
-
-    should "display correct unchecked hidden field when specified" do
-      actual_html = standard_builder.check_box(:show_favorites, :value => 'female', :uncheck_value => 'false')
-      assert_has_tag('input[type=hidden]', :name => 'user[show_favorites]', :value => 'false') { actual_html }
-    end
-
-    should "display correct checkbox in haml" do
-      visit '/haml/form_for'
-      assert_have_selector '#demo input[type=checkbox]', :checked => 'checked', :id => 'markup_user_remember_me', :name => 'markup_user[remember_me]'
-    end
-
-    should "display correct checkbox in erb" do
-      visit '/erb/form_for'
-      assert_have_selector '#demo input[type=checkbox]', :checked => 'checked', :id => 'markup_user_remember_me', :name => 'markup_user[remember_me]'
-    end
-
-    should "display correct checkbox in slim" do
-      visit '/slim/form_for'
-      assert_have_selector '#demo input[type=checkbox]', :checked => 'checked', :id => 'markup_user_remember_me', :name => 'markup_user[remember_me]'
-    end
-  end
-
-  context 'for #radio_button method' do
-    should "display correct radio button html" do
-      actual_html = standard_builder.radio_button(:gender, :value => 'male', :class => 'large')
-      assert_has_tag('input.large[type=radio]', :id => 'user_gender_male', :name => 'user[gender]', :value => 'male') { actual_html }
-    end
-
-    should "display correct radio button html when checked" do
-      actual_html = standard_builder.radio_button(:gender, :checked => true)
-      assert_has_tag('input[type=radio]', :checked => 'checked', :name => 'user[gender]') { actual_html }
-    end
-
-    should "display correct radio button html as checked when object value matches" do
-      @user.stubs(:gender => 'male')
-      actual_html = standard_builder.radio_button(:gender, :value => 'male')
-      assert_has_tag('input[type=radio]', :checked => 'checked', :name => 'user[gender]') { actual_html }
-    end
-
-    should "display correct radio button html as unchecked when object value doesn't match" do
-      @user.stubs(:gender => 'male')
-      actual_html = standard_builder.radio_button(:gender, :value => 'female')
-      assert_has_no_tag('input[type=radio]', :checked => 'checked') { actual_html }
-    end
-
-    should "display correct radio button in haml" do
-      visit '/haml/form_for'
-      assert_have_selector '#demo input[type=radio]', :id => 'markup_user_gender_male', :name => 'markup_user[gender]', :value => 'male'
-      assert_have_selector '#demo input[type=radio]', :id => 'markup_user_gender_female', :name => 'markup_user[gender]', :value => 'female'
-      assert_have_selector '#demo input[type=radio][checked=checked]', :id => 'markup_user_gender_male'
-    end
-
-    should "display correct radio button in erb" do
-      visit '/erb/form_for'
-      assert_have_selector '#demo input[type=radio]', :id => 'markup_user_gender_male', :name => 'markup_user[gender]', :value => 'male'
-      assert_have_selector '#demo input[type=radio]', :id => 'markup_user_gender_female', :name => 'markup_user[gender]', :value => 'female'
-      assert_have_selector '#demo input[type=radio][checked=checked]', :id => 'markup_user_gender_male'
-    end
-
-    should "display correct radio button in slim" do
-      visit '/slim/form_for'
-      assert_have_selector '#demo input[type=radio]', :id => 'markup_user_gender_male', :name => 'markup_user[gender]', :value => 'male'
-      assert_have_selector '#demo input[type=radio]', :id => 'markup_user_gender_female', :name => 'markup_user[gender]', :value => 'female'
-      assert_have_selector '#demo input[type=radio][checked=checked]', :id => 'markup_user_gender_male'
-    end
-  end
-
-  context 'for #text_area method' do
-    should "display correct text_area html" do
-      actual_html = standard_builder.text_area(:about, :class => 'large')
-      assert_has_tag('textarea.large', :id => 'user_about', :name => 'user[about]', :rows => '', :cols => '') { actual_html }
-    end
-
-    should "display correct text_area html and content" do
-      actual_html = standard_builder.text_area(:about, :value => "Demo", :rows => '5', :cols => '6')
-      assert_has_tag('textarea', :id => 'user_about', :content => 'Demo', :rows => '5', :cols => '6') { actual_html }
-    end
-
-    should "display correct text_area in haml" do
-      visit '/haml/form_for'
-      assert_have_selector '#demo textarea', :name => 'markup_user[about]', :id => 'markup_user_about', :class => 'user-about'
-      assert_have_selector '#demo2 textarea', :name => 'markup_user[about]', :id => 'markup_user_about', :class => 'textarea'
-    end
-
-    should "display correct text_area in erb" do
-      visit '/erb/form_for'
-      assert_have_selector '#demo textarea', :name => 'markup_user[about]', :id => 'markup_user_about', :class => 'user-about'
-      assert_have_selector '#demo2 textarea', :name => 'markup_user[about]', :id => 'markup_user_about', :class => 'textarea'
-    end
-
-    should "display correct text_area in slim" do
-      visit '/slim/form_for'
-      assert_have_selector '#demo textarea', :name => 'markup_user[about]', :id => 'markup_user_about', :class => 'user-about'
-      assert_have_selector '#demo2 textarea', :name => 'markup_user[about]', :id => 'markup_user_about', :class => 'textarea'
-    end
-  end
-
-  context 'for #password_field method' do
-    should "display correct password_field html" do
-      actual_html = standard_builder.password_field(:code, :class => 'large')
-      assert_has_tag('input.large[type=password]', :id => 'user_code', :name => 'user[code]') { actual_html }
-    end
-
-    should "display correct password_field in haml" do
-      visit '/haml/form_for'
-      assert_have_selector '#demo input', :type => 'password', :class => 'user-password', :value => 'secret'
-      assert_have_selector '#demo2 input', :type => 'password', :class => 'input', :name => 'markup_user[code]'
-    end
-
-    should "display correct password_field in erb" do
-      visit '/erb/form_for'
-      assert_have_selector '#demo input', :type => 'password', :class => 'user-password', :value => 'secret'
-      assert_have_selector '#demo2 input', :type => 'password', :class => 'input', :name => 'markup_user[code]'
-    end
-
-    should "display correct password_field in slim" do
-      visit '/slim/form_for'
-      assert_have_selector '#demo input', :type => 'password', :class => 'user-password', :value => 'secret'
-      assert_have_selector '#demo2 input', :type => 'password', :class => 'input', :name => 'markup_user[code]'
-    end
-  end
-
-  context 'for #file_field method' do
-    should "display correct file_field html" do
-      actual_html = standard_builder.file_field(:photo, :class => 'large')
-      assert_has_tag('input.large[type=file]', :id => 'user_photo', :name => 'user[photo]') { actual_html }
-    end
-
-    should "display correct file_field in haml" do
-      visit '/haml/form_for'
-      assert_have_selector '#demo  input.user-photo', :type => 'file', :name => 'markup_user[photo]', :id => 'markup_user_photo'
-      assert_have_selector '#demo2 input.upload', :type => 'file', :name => 'markup_user[photo]', :id => 'markup_user_photo'
-    end
-
-    should "display correct file_field in erb" do
-      visit '/erb/form_for'
-      assert_have_selector '#demo  input.user-photo', :type => 'file', :name => 'markup_user[photo]', :id => 'markup_user_photo'
-      assert_have_selector '#demo2 input.upload', :type => 'file', :name => 'markup_user[photo]', :id => 'markup_user_photo'
-    end
-
-    should "display correct file_field in slim" do
-      visit '/slim/form_for'
-      assert_have_selector '#demo  input.user-photo', :type => 'file', :name => 'markup_user[photo]', :id => 'markup_user_photo'
-      assert_have_selector '#demo2 input.upload', :type => 'file', :name => 'markup_user[photo]', :id => 'markup_user_photo'
-    end
-  end
-
-  context 'for #select method' do
-    should "display correct select html" do
-      actual_html = standard_builder.select(:state, :options => ['California', 'Texas', 'Wyoming'], :class => 'selecty')
-      assert_has_tag('select.selecty', :id => 'user_state', :name => 'user[state]') { actual_html }
-      assert_has_tag('select.selecty option', :count => 3) { actual_html }
-      assert_has_tag('select.selecty option', :value => 'California', :content => 'California') { actual_html }
-      assert_has_tag('select.selecty option', :value => 'Texas',      :content => 'Texas')      { actual_html }
-      assert_has_tag('select.selecty option', :value => 'Wyoming',    :content => 'Wyoming')    { actual_html }
-    end
-
-    should "display correct select html with selected item if it matches value" do
-      @user.stubs(:state => 'California')
-      actual_html = standard_builder.select(:state, :options => ['California', 'Texas', 'Wyoming'])
-      assert_has_tag('select', :id => 'user_state', :name => 'user[state]') { actual_html }
-      assert_has_tag('select option', :selected => 'selected', :count => 1) { actual_html }
-      assert_has_tag('select option', :value => 'California', :selected => 'selected') { actual_html }
-    end
-
-    should "display correct select html with selected item if it matches full value" do
-      @user.stubs(:state => 'Cali')
-      actual_html = standard_builder.select(:state, :options => ['Cali', 'California', 'Texas', 'Wyoming'])
-      assert_has_tag('select', :id => 'user_state', :name => 'user[state]') { actual_html }
-      assert_has_tag('select option', :selected => 'selected', :count => 1) { actual_html }
-      assert_has_tag('select option', :value => 'Cali', :selected => 'selected') { actual_html }
-      assert_has_tag('select option', :value => 'California') { actual_html }
-    end
-
-    should "display correct select html with multiple selected items" do
-      @user.stubs(:pickles => ['foo', 'bar'])
-      actual_html = standard_builder.select(
-        :pickles, :options => [ ['Foo', 'foo'], ['Bar', 'bar'], ['Baz', 'baz'], ['Bar Buz', 'bar buz'] ]
-      )
-      assert_has_tag('option', :value => 'foo', :content => 'Foo', :selected => 'selected')  { actual_html }
-      assert_has_tag('option', :value => 'bar', :content => 'Bar', :selected => 'selected')  { actual_html }
-      assert_has_tag('option', :value => 'baz', :content => 'Baz')  { actual_html }
-      assert_has_tag('option', :value => 'bar buz', :content => 'Bar Buz')  { actual_html }
-    end
-
-    should "display correct select html with include_blank" do
-      actual_html = standard_builder.select(:state, :options => ['California', 'Texas', 'Wyoming'], :include_blank => true)
-      assert_has_tag('select', :id => 'user_state', :name => 'user[state]') { actual_html }
-      assert_has_tag('select option', :count => 4) { actual_html }
-      assert_has_tag('select option:first-child', :content => '') { actual_html }
-      assert_has_tag('select option:first-child', :value => '') { actual_html }
-      actual_html = standard_builder.select(:state, :options => ['California', 'Texas', 'Wyoming'], :include_blank => 'Select')
-      assert_has_tag('select', :id => 'user_state', :name => 'user[state]') { actual_html }
-      assert_has_tag('select option', :count => 4) { actual_html }
-      assert_has_tag('select option:first-child', :content => 'Select') { actual_html }
-      assert_has_tag('select option:first-child', :value => '') { actual_html }
-    end
-
-    should "display correct select html with collection passed in" do
-      actual_html = standard_builder.select(:role, :collection => @user.role_types, :fields => [:name, :id])
-      assert_has_tag('select', :id => 'user_role', :name => 'user[role]') { actual_html }
-      assert_has_tag('select option', :count => 3) { actual_html }
-      assert_has_tag('select option', :value => '1', :content => 'Admin', :selected => 'selected')     { actual_html }
-      assert_has_tag('select option', :value => '2', :content => 'Moderate')  { actual_html }
-      assert_has_tag('select option', :value => '3', :content => 'Limited')   { actual_html }
-    end
-
-    should "display correct select in haml" do
-      visit '/haml/form_for'
-      assert_have_selector '#demo textarea', :name => 'markup_user[about]', :id => 'markup_user_about', :class => 'user-about'
-      assert_have_selector '#demo2 textarea', :name => 'markup_user[about]', :id => 'markup_user_about', :class => 'textarea'
-    end
-
-    should "display correct select in erb" do
-      visit '/erb/form_for'
-      assert_have_selector '#demo textarea', :name => 'markup_user[about]', :id => 'markup_user_about', :class => 'user-about'
-      assert_have_selector '#demo2 textarea', :name => 'markup_user[about]', :id => 'markup_user_about', :class => 'textarea'
-    end
-
-    should "display correct select in slim" do
-      visit '/slim/form_for'
-      assert_have_selector '#demo textarea', :name => 'markup_user[about]', :id => 'markup_user_about', :class => 'user-about'
-      assert_have_selector '#demo2 textarea', :name => 'markup_user[about]', :id => 'markup_user_about', :class => 'textarea'
-    end
-  end
-
-  context 'for #submit method' do
-    should "display correct submit button html with no options" do
-      actual_html = standard_builder.submit
-      assert_has_tag('input[type=submit]', :value => "Submit") { actual_html }
-    end
-
-    should "display correct submit button html" do
-      actual_html = standard_builder.submit("Commit", :class => 'large')
-      assert_has_tag('input.large[type=submit]', :value => "Commit") { actual_html }
-    end
-
-    should "display correct submit button in haml" do
-      visit '/haml/form_for'
-      assert_have_selector '#demo input', :type => 'submit', :id => 'demo-button', :class => 'success'
-      assert_have_selector '#demo2 input', :type => 'submit', :class => 'button', :value => "Create"
-    end
-
-    should "display correct submit button in erb" do
-      visit '/erb/form_for'
-      assert_have_selector '#demo input', :type => 'submit', :id => 'demo-button', :class => 'success'
-      assert_have_selector '#demo2 input', :type => 'submit', :class => 'button', :value => "Create"
-    end
-
-    should "display correct submit button in slim" do
-      visit '/slim/form_for'
-      assert_have_selector '#demo input', :type => 'submit', :id => 'demo-button', :class => 'success'
-      assert_have_selector '#demo2 input', :type => 'submit', :class => 'button', :value => "Create"
-    end
-  end
-
-  context 'for #image_submit method' do
-    setup do
-      @stamp = stop_time_for_test.to_i
-    end
-
-    should "display correct image submit button html with no options" do
-      actual_html = standard_builder.image_submit('buttons/ok.png')
-      assert_has_tag('input[type=image]', :src => "/images/buttons/ok.png?#{@stamp}") { actual_html }
-    end
-
-    should "display correct image submit button html" do
-      actual_html = standard_builder.image_submit('/system/ok.png', :class => 'large')
-      assert_has_tag('input.large[type=image]', :src => "/system/ok.png?#{@stamp}") { actual_html }
-    end
-
-    should "display correct image submit button in haml" do
-      visit '/haml/form_for'
-      assert_have_selector '#demo input', :type => 'image', :id => 'image-button', :src => "/images/buttons/post.png?#{@stamp}"
-      assert_have_selector '#demo2 input', :type => 'image', :class => 'image', :src => "/images/buttons/ok.png?#{@stamp}"
-    end
-
-    should "display correct image submit button in erb" do
-      visit '/erb/form_for'
-      assert_have_selector '#demo input', :type => 'image', :id => 'image-button', :src => "/images/buttons/post.png?#{@stamp}"
-      assert_have_selector '#demo2 input', :type => 'image', :class => 'image', :src => "/images/buttons/ok.png?#{@stamp}"
-    end
-
-    should "display correct image submit button in slim" do
-      visit '/slim/form_for'
-      assert_have_selector '#demo input', :type => 'image', :id => 'image-button', :src => "/images/buttons/post.png?#{@stamp}"
-      assert_have_selector '#demo2 input', :type => 'image', :class => 'image', :src => "/images/buttons/ok.png?#{@stamp}"
-    end
-  end
-
-  context 'for #fields_for method' do
-    setup do
-      @telephone = mock_model("Telephone", :number => "4568769876")
-      @user.stubs(:telephone).returns(@telephone)
-      @businesses = [ mock_model("Business", :name => "Silver", :new_record? => false, :id => 20) ]
-      @businesses <<  mock_model("Business", :name => "Gold", :new_record? => true)
-      @addresses = [ mock_model("Address", :name => "Foo", :new_record? => false, :id => 20, :businesses => @businesses) ]
-      @addresses <<  mock_model("Address", :name => "Bar", :new_record? => true, :businesses => @businesses)
-      @user.stubs(:addresses).returns(@addresses)
-    end
-
-    should "display nested children fields one-to-one within form" do
-      actual_html = standard_builder.fields_for :telephone do |child_form|
-        child_form.label(:number) +
-        child_form.text_field(:number) +
-        child_form.check_box('_destroy')
-      end
-      assert_has_tag('label', :for => 'user_telephone_attributes_number') { actual_html }
-      assert_has_tag('input', :type => 'text', :id => 'user_telephone_attributes_number', :name => 'user[telephone_attributes][number]', :value => "4568769876") { actual_html }
-      assert_has_tag('input', :type => 'hidden', :name => 'user[telephone_attributes][_destroy]', :value => '0') { actual_html }
-      assert_has_tag('input', :type => 'checkbox', :id => 'user_telephone_attributes__destroy', :name => 'user[telephone_attributes][_destroy]', :value => '1') { actual_html }
-    end
-
-    should "display nested children fields one-to-many within form" do
-      actual_html = standard_builder.fields_for(:addresses) do |child_form|
-        html = child_form.label(:name)
-        html << child_form.check_box('_destroy') unless child_form.object.new_record?
-        html << child_form.text_field(:name)
-      end
-      # Address 1 (Saved)
-      assert_has_tag('input', :type => 'hidden', :id => 'user_addresses_attributes_0_id', :name => "user[addresses_attributes][0][id]", :value => '20') { actual_html }
-      assert_has_tag('label', :for => 'user_addresses_attributes_0_name', :content => 'Name') { actual_html }
-      assert_has_tag('input', :type => 'text', :id => 'user_addresses_attributes_0_name', :name => 'user[addresses_attributes][0][name]') { actual_html }
-      assert_has_tag('input', :type => 'checkbox', :id => 'user_addresses_attributes_0__destroy', :name => 'user[addresses_attributes][0][_destroy]') { actual_html }
-      # Address 2 (New)
-      assert_has_no_tag('input', :type => 'hidden', :id => 'user_addresses_attributes_1_id') { actual_html }
-      assert_has_tag('label', :for => 'user_addresses_attributes_1_name', :content => 'Name') { actual_html }
-      assert_has_tag('input', :type => 'text', :id => 'user_addresses_attributes_1_name', :name => 'user[addresses_attributes][1][name]') { actual_html }
-      assert_has_no_tag('input', :type => 'checkbox', :id => 'user_addresses_attributes_1__destroy') { actual_html }
-    end
-
-    should "display fields for explicit instance object" do
-      address = mock_model("Address", :name => "Page", :new_record? => false, :id => 40)
-      actual_html = standard_builder.fields_for(:addresses, address) do |child_form|
-        html = child_form.label(:name)
-        html << child_form.text_field(:name)
-        html << child_form.check_box('_destroy')
-      end
-      assert_has_tag('input', :type => 'hidden', :id => 'user_addresses_attributes_0_id', :name => "user[addresses_attributes][0][id]", :value => '40') { actual_html }
-      assert_has_tag('label', :for => 'user_addresses_attributes_0_name', :content => 'Name') { actual_html }
-      assert_has_tag('input', :type => 'text', :id => 'user_addresses_attributes_0_name', :name => 'user[addresses_attributes][0][name]', :value => "Page") { actual_html }
-      assert_has_tag('input', :type => 'checkbox', :id => 'user_addresses_attributes_0__destroy', :name => 'user[addresses_attributes][0][_destroy]', :value => '1') { actual_html }
-    end
-
-    should "display fields for collection object" do
-      addresses = @addresses + [mock_model("Address", :name => "Walter", :new_record? => false, :id => 50)]
-      actual_html = standard_builder.fields_for(:addresses, addresses) do |child_form|
-        child_form.label(:name) +
-        child_form.text_field(:name) +
-        child_form.check_box('_destroy')
-      end
-      # Address 1
-      assert_has_tag('input', :type => 'hidden', :id => 'user_addresses_attributes_0_id', :name => "user[addresses_attributes][0][id]", :value => '20') { actual_html }
-      assert_has_tag('label', :for => 'user_addresses_attributes_0_name', :content => 'Name') { actual_html }
-      assert_has_tag('input', :type => 'text', :id => 'user_addresses_attributes_0_name', :name => 'user[addresses_attributes][0][name]', :value => "Foo") { actual_html }
-      assert_has_tag('input', :type => 'checkbox', :id => 'user_addresses_attributes_0__destroy', :name => 'user[addresses_attributes][0][_destroy]') { actual_html }
-      # Address 3
-      assert_has_tag('input', :type => 'hidden', :id => 'user_addresses_attributes_2_id', :value => '50') { actual_html }
-      assert_has_tag('label', :for => 'user_addresses_attributes_2_name', :content => 'Name') { actual_html }
-      assert_has_tag('input', :type => 'text', :id => 'user_addresses_attributes_2_name', :name => 'user[addresses_attributes][2][name]', :value => "Walter") { actual_html }
-      assert_has_tag('input', :type => 'checkbox', :id => 'user_addresses_attributes_2__destroy') { actual_html }
-    end
-
-    should "display fields for arbitrarily deep nested forms" do
-      actual_html = standard_builder.fields_for :addresses do |child_form|
-        child_form.fields_for(:businesses) do |second_child_form|
-          second_child_form.label(:name) +
-          second_child_form.text_field(:name) +
-          second_child_form.check_box('_destroy')
-        end
-      end
-      assert_has_tag('label', :for => 'user_addresses_attributes_1_businesses_attributes_0_name', :content => 'Name') { actual_html }
-      assert_has_tag('input', :type => 'text', :id => 'user_addresses_attributes_1_businesses_attributes_0_name', :name => 'user[addresses_attributes][1][businesses_attributes][0][name]') { actual_html }
-    end
-
-    should "display nested children fields in erb" do
-      visit '/erb/fields_for'
-      # Telephone
-      assert_have_selector('label', :for => 'markup_user_telephone_attributes_number')
-      assert_have_selector('input', :type => 'text', :id => 'markup_user_telephone_attributes_number', :name => 'markup_user[telephone_attributes][number]', :value => "62634576545")
-      # Address 1 (Saved)
-      assert_have_selector('input', :type => 'hidden', :id => 'markup_user_addresses_attributes_0_id', :name => "markup_user[addresses_attributes][0][id]", :value => '25')
-      assert_have_selector('label', :for => 'markup_user_addresses_attributes_0_name', :content => 'Name')
-      assert_have_selector('input', :type => 'text', :id => 'markup_user_addresses_attributes_0_name', :name => 'markup_user[addresses_attributes][0][name]')
-      assert_have_selector('input', :type => 'checkbox', :id => 'markup_user_addresses_attributes_0__destroy', :name => 'markup_user[addresses_attributes][0][_destroy]')
-      # Address 2 (New)
-      assert_have_no_selector('input', :type => 'hidden', :id => 'markup_user_addresses_attributes_1_id')
-      assert_have_selector('label', :for => 'markup_user_addresses_attributes_1_name', :content => 'Name')
-      assert_have_selector('input', :type => 'text', :id => 'markup_user_addresses_attributes_1_name', :name => 'markup_user[addresses_attributes][1][name]')
-      assert_have_no_selector('input', :type => 'checkbox', :id => 'markup_user_addresses_attributes_1__destroy')
-    end
-
-    should "display nested children fields in haml" do
-      visit '/haml/fields_for'
-      # Telephone
-      assert_have_selector('label', :for => 'markup_user_telephone_attributes_number')
-      assert_have_selector('input', :type => 'text', :id => 'markup_user_telephone_attributes_number', :name => 'markup_user[telephone_attributes][number]', :value => "62634576545")
-      # Address 1 (Saved)
-      assert_have_selector('input', :type => 'hidden', :id => 'markup_user_addresses_attributes_0_id', :name => "markup_user[addresses_attributes][0][id]", :value => '25')
-      assert_have_selector('label', :for => 'markup_user_addresses_attributes_0_name', :content => 'Name')
-      assert_have_selector('input', :type => 'text', :id => 'markup_user_addresses_attributes_0_name', :name => 'markup_user[addresses_attributes][0][name]')
-      assert_have_selector('input', :type => 'checkbox', :id => 'markup_user_addresses_attributes_0__destroy', :name => 'markup_user[addresses_attributes][0][_destroy]')
-      # Address 2 (New)
-      assert_have_no_selector('input', :type => 'hidden', :id => 'markup_user_addresses_attributes_1_id')
-      assert_have_selector('label', :for => 'markup_user_addresses_attributes_1_name', :content => 'Name')
-      assert_have_selector('input', :type => 'text', :id => 'markup_user_addresses_attributes_1_name', :name => 'markup_user[addresses_attributes][1][name]')
-      assert_have_no_selector('input', :type => 'checkbox', :id => 'markup_user_addresses_attributes_1__destroy')
-    end
-
-    should "display nested children fields in slim" do
-      visit '/slim/fields_for'
-      # Telephone
-      assert_have_selector('label', :for => 'markup_user_telephone_attributes_number')
-      assert_have_selector('input', :type => 'text', :id => 'markup_user_telephone_attributes_number', :name => 'markup_user[telephone_attributes][number]', :value => "62634576545")
-      # Address 1 (Saved)
-      assert_have_selector('input', :type => 'hidden', :id => 'markup_user_addresses_attributes_0_id', :name => "markup_user[addresses_attributes][0][id]", :value => '25')
-      assert_have_selector('label', :for => 'markup_user_addresses_attributes_0_name', :content => 'Name')
-      assert_have_selector('input', :type => 'text', :id => 'markup_user_addresses_attributes_0_name', :name => 'markup_user[addresses_attributes][0][name]')
-      assert_have_selector('input', :type => 'checkbox', :id => 'markup_user_addresses_attributes_0__destroy', :name => 'markup_user[addresses_attributes][0][_destroy]')
-      # Address 2 (New)
-      assert_have_no_selector('input', :type => 'hidden', :id => 'markup_user_addresses_attributes_1_id')
-      assert_have_selector('label', :for => 'markup_user_addresses_attributes_1_name', :content => 'Name')
-      assert_have_selector('input', :type => 'text', :id => 'markup_user_addresses_attributes_1_name', :name => 'markup_user[addresses_attributes][1][name]')
-      assert_have_no_selector('input', :type => 'checkbox', :id => 'markup_user_addresses_attributes_1__destroy')
-    end
-  end
-
-  # ===========================
-  # StandardFormBuilder
-  # ===========================
-
-  context 'for #text_field_block method' do
-    should "display correct text field block html" do
-      actual_html = standard_builder.text_field_block(:first_name, :class => 'large', :caption => "FName")
-      assert_has_tag('p label', :for => 'user_first_name', :content => "FName") { actual_html }
-      assert_has_tag('p input.large[type=text]', :value => "Joe", :id => 'user_first_name', :name => 'user[first_name]') { actual_html }
-    end
-
-    should "display correct text field block in haml" do
-      visit '/haml/form_for'
-      assert_have_selector '#demo2 p label', :for => 'markup_user_username', :content => "Nickname: ", :class => 'label'
-      assert_have_selector '#demo2 p input', :type => 'text', :name => 'markup_user[username]', :id => 'markup_user_username'
-    end
-
-    should "display correct text field block in erb" do
-      visit '/erb/form_for'
-      assert_have_selector '#demo2 p label', :for => 'markup_user_username', :content => "Nickname: ", :class => 'label'
-      assert_have_selector '#demo2 p input', :type => 'text', :name => 'markup_user[username]', :id => 'markup_user_username'
-    end
-
-    should "display correct text field block in slim" do
-      visit '/slim/form_for'
-      assert_have_selector '#demo2 p label', :for => 'markup_user_username', :content => "Nickname: ", :class => 'label'
-      assert_have_selector '#demo2 p input', :type => 'text', :name => 'markup_user[username]', :id => 'markup_user_username'
-    end
-  end
-
-  context 'for #text_area_block method' do
-    should "display correct text area block html" do
-      actual_html = standard_builder.text_area_block(:about, :class => 'large', :caption => "About Me")
-      assert_has_tag('p label', :for => 'user_about', :content => "About Me") { actual_html }
-      assert_has_tag('p textarea', :id => 'user_about', :name => 'user[about]') { actual_html }
-    end
-
-    should "display correct text area block in haml" do
-      visit '/haml/form_for'
-      assert_have_selector '#demo2 p label', :for => 'markup_user_about', :content => "About: "
-      assert_have_selector '#demo2 p textarea', :name => 'markup_user[about]', :id => 'markup_user_about'
-    end
-
-    should "display correct text area block in erb" do
-      visit '/erb/form_for'
-      assert_have_selector '#demo2 p label', :for => 'markup_user_about', :content => "About: "
-      assert_have_selector '#demo2 p textarea', :name => 'markup_user[about]', :id => 'markup_user_about'
-    end
-
-    should "display correct text area block in slim" do
-      visit '/slim/form_for'
-      assert_have_selector '#demo2 p label', :for => 'markup_user_about', :content => "About: "
-      assert_have_selector '#demo2 p textarea', :name => 'markup_user[about]', :id => 'markup_user_about'
-    end
-  end
-
-  context 'for #password_field_block method' do
-    should "display correct password field block html" do
-      actual_html = standard_builder.password_field_block(:keycode, :class => 'large', :caption => "Code: ")
-      assert_has_tag('p label', :for => 'user_keycode', :content => "Code: ") { actual_html }
-      assert_has_tag('p input.large[type=password]', :id => 'user_keycode', :name => 'user[keycode]') { actual_html }
-    end
-
-    should "display correct password field block in haml" do
-      visit '/haml/form_for'
-      assert_have_selector '#demo2 p label', :for => 'markup_user_code', :content => "Code: "
-      assert_have_selector '#demo2 p input', :type => 'password', :name => 'markup_user[code]', :id => 'markup_user_code'
-    end
-
-    should "display correct password field block in erb" do
-      visit '/erb/form_for'
-      assert_have_selector '#demo2 p label', :for => 'markup_user_code', :content => "Code: "
-      assert_have_selector '#demo2 p input', :type => 'password', :name => 'markup_user[code]', :id => 'markup_user_code'
-    end
-
-    should "display correct password field block in slim" do
-      visit '/slim/form_for'
-      assert_have_selector '#demo2 p label', :for => 'markup_user_code', :content => "Code: "
-      assert_have_selector '#demo2 p input', :type => 'password', :name => 'markup_user[code]', :id => 'markup_user_code'
-    end
-  end
-
-  context 'for #file_field_block method' do
-    should "display correct file field block html" do
-      actual_html = standard_builder.file_field_block(:photo, :class => 'large', :caption => "Photo: ")
-      assert_has_tag('p label', :for => 'user_photo', :content => "Photo: ") { actual_html }
-      assert_has_tag('p input.large[type=file]', :id => 'user_photo', :name => 'user[photo]') { actual_html }
-    end
-
-    should "display correct file field block in haml" do
-      visit '/haml/form_for'
-      assert_have_selector '#demo2 p label', :for => 'markup_user_photo', :content => "Photo: "
-      assert_have_selector '#demo2 p input.upload', :type => 'file', :name => 'markup_user[photo]', :id => 'markup_user_photo'
-    end
-
-    should "display correct file field block in erb" do
-      visit '/erb/form_for'
-      assert_have_selector '#demo2 p label', :for => 'markup_user_photo', :content => "Photo: "
-      assert_have_selector '#demo2 p input.upload', :type => 'file', :name => 'markup_user[photo]', :id => 'markup_user_photo'
-    end
-
-    should "display correct file field block in slim" do
-      visit '/slim/form_for'
-      assert_have_selector '#demo2 p label', :for => 'markup_user_photo', :content => "Photo: "
-      assert_have_selector '#demo2 p input.upload', :type => 'file', :name => 'markup_user[photo]', :id => 'markup_user_photo'
-    end
-  end
-
-  context 'for #check_box_block method' do
-    should "display correct check box block html" do
-      actual_html = standard_builder.check_box_block(:remember_me, :class => 'large', :caption => "Remember session?")
-      assert_has_tag('p label', :for => 'user_remember_me', :content => "Remember session?") { actual_html }
-      assert_has_tag('p input.large[type=checkbox]', :id => 'user_remember_me', :name => 'user[remember_me]') { actual_html }
-    end
-
-    should "display correct check box block in haml" do
-      visit '/haml/form_for'
-      assert_have_selector '#demo2 p label', :for => 'markup_user_remember_me', :content => "Remember me: "
-      assert_have_selector '#demo2 p input.checker', :type => 'checkbox', :name => 'markup_user[remember_me]'
-    end
-
-    should "display correct check box block in erb" do
-      visit '/erb/form_for'
-      assert_have_selector '#demo2 p label', :for => 'markup_user_remember_me', :content => "Remember me: "
-      assert_have_selector '#demo2 p input.checker', :type => 'checkbox', :name => 'markup_user[remember_me]'
-    end
-
-    should "display correct check box block in slim" do
-      visit '/slim/form_for'
-      assert_have_selector '#demo2 p label', :for => 'markup_user_remember_me', :content => "Remember me: "
-      assert_have_selector '#demo2 p input.checker', :type => 'checkbox', :name => 'markup_user[remember_me]'
-    end
-  end
-
-  context 'for #select_block method' do
-    should "display correct select_block block html" do
-      actual_html = standard_builder.select_block(:country, :options => ['USA', 'Canada'], :class => 'large', :caption => "Your country")
-      assert_has_tag('p label', :for => 'user_country', :content => "Your country") { actual_html }
-      assert_has_tag('p select', :id => 'user_country', :name => 'user[country]') { actual_html }
-      assert_has_tag('p select option', :content => 'USA')   { actual_html }
-      assert_has_tag('p select option', :content => 'Canada') { actual_html }
-    end
-
-    should "display correct select_block block in haml" do
-      visit '/haml/form_for'
-      assert_have_selector '#demo2 p label', :for => 'markup_user_state', :content => "State: "
-      assert_have_selector '#demo2 p select', :name => 'markup_user[state]', :id => 'markup_user_state'
-      assert_have_selector '#demo2 p select option',  :content => 'California'
-      assert_have_selector '#demo2 p select option',  :content => 'Texas'
-    end
-
-    should "display correct select_block block in erb" do
-      visit '/erb/form_for'
-      assert_have_selector '#demo2 p label', :for => 'markup_user_state', :content => "State: "
-      assert_have_selector '#demo2 p select', :name => 'markup_user[state]', :id => 'markup_user_state'
-    end
-
-    should "display correct select_block block in slim" do
-      visit '/slim/form_for'
-      assert_have_selector '#demo2 p label', :for => 'markup_user_state', :content => "State: "
-      assert_have_selector '#demo2 p select', :name => 'markup_user[state]', :id => 'markup_user_state'
-    end
-  end
-
-  context 'for #submit_block method' do
-    should "display correct submit block html" do
-      actual_html = standard_builder.submit_block("Update", :class => 'large')
-      assert_has_tag('p input.large[type=submit]', :value => 'Update') { actual_html }
-    end
-
-    should "display correct submit block in haml" do
-      visit '/haml/form_for'
-      assert_have_selector '#demo2 p input', :type => 'submit', :class => 'button'
-    end
-
-    should "display correct submit block in erb" do
-      visit '/erb/form_for'
-      assert_have_selector '#demo2 p input', :type => 'submit', :class => 'button'
-    end
-
-    should "display correct submit block in slim" do
-      visit '/slim/form_for'
-      assert_have_selector '#demo2 p input', :type => 'submit', :class => 'button'
-    end
-  end
-
-  context 'for #image_submit_block method' do
-    setup do
-      @stamp = stop_time_for_test.to_i
-    end
-
-    should "display correct image submit block html" do
-      actual_html = standard_builder.image_submit_block("buttons/ok.png", :class => 'large')
-      assert_has_tag('p input.large[type=image]', :src => "/images/buttons/ok.png?#{@stamp}") { actual_html }
-    end
-
-    should "display correct image submit block in haml" do
-      visit '/haml/form_for'
-      assert_have_selector '#demo2 p input', :type => 'image', :class => 'image', :src => "/images/buttons/ok.png?#{@stamp}"
-    end
-
-    should "display correct image submit block in slim" do
-      visit '/slim/form_for'
-      assert_have_selector '#demo2 p input', :type => 'image', :class => 'image', :src => "/images/buttons/ok.png?#{@stamp}"
-    end
-  end
-end