Merge commit 'rails/master'

16 files changed, 139 insertions, 76 deletions

diff --git a/actionpack/test/abstract_controller/abstract_controller_test.rb b/actionpack/test/abstract_controller/abstract_controller_test.rb
index 9c028e7d1e..c7eaaeb4ba 100644
--- a/actionpack/test/abstract_controller/abstract_controller_test.rb
+++ b/actionpack/test/abstract_controller/abstract_controller_test.rb
@@ -19,7 +19,7 @@ module AbstractController
     
     class TestBasic < ActiveSupport::TestCase
       test "dispatching works" do
-        result = Me.process(:index)
+        result = Me.new.process(:index)
         assert_equal "Hello world", result.response_body
       end
     end
@@ -68,27 +68,27 @@ module AbstractController
     
     class TestRenderer < ActiveSupport::TestCase
       test "rendering templates works" do
-        result = Me2.process(:index)
+        result = Me2.new.process(:index)
         assert_equal "Hello from index.erb", result.response_body
       end
       
       test "rendering passes ivars to the view" do
-        result = Me2.process(:action_with_ivars)
+        result = Me2.new.process(:action_with_ivars)
         assert_equal "Hello from index_with_ivars.erb", result.response_body
       end
       
       test "rendering with no template name" do
-        result = Me2.process(:naked_render)
+        result = Me2.new.process(:naked_render)
         assert_equal "Hello from naked_render.erb", result.response_body
       end
 
       test "rendering to a rack body" do
-        result = Me2.process(:rendering_to_body)
+        result = Me2.new.process(:rendering_to_body)
         assert_equal "Hello from naked_render.erb", result.response_body
       end
 
       test "rendering to a string" do
-        result = Me2.process(:rendering_to_string)
+        result = Me2.new.process(:rendering_to_string)
         assert_equal "Hello from naked_render.erb", result.response_body
       end
     end
@@ -120,12 +120,12 @@ module AbstractController
     
     class TestPrefixedViews < ActiveSupport::TestCase
       test "templates are located inside their 'prefix' folder" do
-        result = Me3.process(:index)
+        result = Me3.new.process(:index)
         assert_equal "Hello from me3/index.erb", result.response_body
       end
 
       test "templates included their format" do
-        result = Me3.process(:formatted)
+        result = Me3.new.process(:formatted)
         assert_equal "Hello from me3/formatted.html.erb", result.response_body
       end
     end
@@ -173,7 +173,7 @@ module AbstractController
     
     class TestLayouts < ActiveSupport::TestCase
       test "layouts are included" do
-        result = Me4.process(:index)
+        result = Me4.new.process(:index)
         assert_equal "Me4 Enter : Hello from me4/index.erb : Exit", result.response_body
       end
     end
@@ -210,7 +210,7 @@ module AbstractController
     class TestRespondToAction < ActiveSupport::TestCase
       
       def assert_dispatch(klass, body = "success", action = :index)
-        response = klass.process(action).response_body
+        response = klass.new.process(action).response_body
         assert_equal body, response
       end
       
@@ -219,7 +219,7 @@ module AbstractController
       end
       
       test "raises ActionNotFound when method does not exist and action_missing is not defined" do
-        assert_raise(ActionNotFound) { DefaultRespondToActionController.process(:fail) }
+        assert_raise(ActionNotFound) { DefaultRespondToActionController.new.process(:fail) }
       end
       
       test "dispatches to action_missing when method does not exist and action_missing is defined" do
@@ -231,7 +231,7 @@ module AbstractController
       end
       
       test "raises ActionNotFound if method is defined but respond_to_action? returns false" do
-        assert_raise(ActionNotFound) { RespondToActionController.process(:fail) }
+        assert_raise(ActionNotFound) { RespondToActionController.new.process(:fail) }
       end
     end
     
diff --git a/actionpack/test/abstract_controller/callbacks_test.rb b/actionpack/test/abstract_controller/callbacks_test.rb
index 1de60868c3..817f60f7d1 100644
--- a/actionpack/test/abstract_controller/callbacks_test.rb
+++ b/actionpack/test/abstract_controller/callbacks_test.rb
@@ -8,7 +8,7 @@ module AbstractController
     end
     
     class Callback1 < ControllerWithCallbacks
-      process_action_callback :before, :first
+      set_callback :process_action, :before, :first
       
       def first
         @text = "Hello world"
@@ -21,7 +21,7 @@ module AbstractController
     
     class TestCallbacks < ActiveSupport::TestCase
       test "basic callbacks work" do
-        result = Callback1.process(:index)
+        result = Callback1.new.process(:index)
         assert_equal "Hello world", result.response_body
       end
     end
@@ -52,17 +52,17 @@ module AbstractController
     
     class TestCallbacks < ActiveSupport::TestCase
       test "before_filter works" do
-        result = Callback2.process(:index)
+        result = Callback2.new.process(:index)
         assert_equal "Hello world", result.response_body
       end
       
       test "after_filter works" do
-        result = Callback2.process(:index)
+        result = Callback2.new.process(:index)
         assert_equal "Goodbye", result.instance_variable_get("@second")
       end
       
       test "around_filter works" do
-        result = Callback2.process(:index)
+        result = Callback2.new.process(:index)
         assert_equal "FIRSTSECOND", result.instance_variable_get("@aroundz")
       end
     end
@@ -83,12 +83,12 @@ module AbstractController
 
     class TestCallbacks < ActiveSupport::TestCase
       test "before_filter works with procs" do
-        result = Callback3.process(:index)
+        result = Callback3.new.process(:index)
         assert_equal "Hello world", result.response_body
       end
       
       test "after_filter works with procs" do
-        result = Callback3.process(:index)
+        result = Callback3.new.process(:index)
         assert_equal "Goodbye", result.instance_variable_get("@second")
       end      
     end
@@ -118,17 +118,17 @@ module AbstractController
     
     class TestCallbacks < ActiveSupport::TestCase
       test "when :only is specified, a before filter is triggered on that action" do
-        result = CallbacksWithConditions.process(:index)
+        result = CallbacksWithConditions.new.process(:index)
         assert_equal "Hello, World", result.response_body
       end
       
       test "when :only is specified, a before filter is not triggered on other actions" do
-        result = CallbacksWithConditions.process(:sekrit_data)
+        result = CallbacksWithConditions.new.process(:sekrit_data)
         assert_equal "true", result.response_body
       end
       
       test "when :except is specified, an after filter is not triggered on that action" do
-        result = CallbacksWithConditions.process(:index)
+        result = CallbacksWithConditions.new.process(:index)
         assert_nil result.instance_variable_get("@authenticated")
       end
     end
@@ -158,17 +158,17 @@ module AbstractController
     
     class TestCallbacks < ActiveSupport::TestCase
       test "when :only is specified with an array, a before filter is triggered on that action" do
-        result = CallbacksWithArrayConditions.process(:index)
+        result = CallbacksWithArrayConditions.new.process(:index)
         assert_equal "Hello, World", result.response_body
       end
       
       test "when :only is specified with an array, a before filter is not triggered on other actions" do
-        result = CallbacksWithArrayConditions.process(:sekrit_data)
+        result = CallbacksWithArrayConditions.new.process(:sekrit_data)
         assert_equal "true", result.response_body
       end
       
       test "when :except is specified with an array, an after filter is not triggered on that action" do
-        result = CallbacksWithArrayConditions.process(:index)
+        result = CallbacksWithArrayConditions.new.process(:index)
         assert_nil result.instance_variable_get("@authenticated")
       end
     end    
@@ -183,12 +183,12 @@ module AbstractController
     
     class TestCallbacks < ActiveSupport::TestCase
       test "when a callback is modified in a child with :only, it works for the :only action" do
-        result = ChangedConditions.process(:index)
+        result = ChangedConditions.new.process(:index)
         assert_equal "Hello world", result.response_body
       end
       
       test "when a callback is modified in a child with :only, it does not work for other actions" do
-        result = ChangedConditions.process(:not_index)
+        result = ChangedConditions.new.process(:not_index)
         assert_equal "", result.response_body        
       end
     end
@@ -207,7 +207,7 @@ module AbstractController
     
     class TestHalting < ActiveSupport::TestCase
       test "when a callback sets the response body, the action should not be invoked" do
-        result = SetsResponseBody.process(:index)
+        result = SetsResponseBody.new.process(:index)
         assert_equal "Success", result.response_body
       end
     end
diff --git a/actionpack/test/abstract_controller/helper_test.rb b/actionpack/test/abstract_controller/helper_test.rb
index f91aefe606..0a2535f834 100644
--- a/actionpack/test/abstract_controller/helper_test.rb
+++ b/actionpack/test/abstract_controller/helper_test.rb
@@ -34,7 +34,7 @@ module AbstractController
     
     class TestHelpers < ActiveSupport::TestCase
       def test_helpers
-        result = MyHelpers1.process(:index)
+        result = MyHelpers1.new.process(:index)
         assert_equal "Hello World : Included", result.response_body
       end
     end
diff --git a/actionpack/test/abstract_controller/layouts_test.rb b/actionpack/test/abstract_controller/layouts_test.rb
index d3440c3de0..4b66f063f3 100644
--- a/actionpack/test/abstract_controller/layouts_test.rb
+++ b/actionpack/test/abstract_controller/layouts_test.rb
@@ -142,7 +142,7 @@ module AbstractControllerTests
     end
     
     # TODO Move to bootloader
-    AbstractController::Base.subclasses.each do |klass|
+    AbstractController::Base.descendants.each do |klass|
       klass = klass.constantize
       next unless klass < AbstractController::Layouts
       klass.class_eval do
@@ -152,70 +152,70 @@ module AbstractControllerTests
     
     class TestBase < ActiveSupport::TestCase
       test "when no layout is specified, and no default is available, render without a layout" do
-        result = Blank.process(:index)
+        result = Blank.new.process(:index)
         assert_equal "Hello blank!", result.response_body
       end
       
       test "when layout is specified as a string, render with that layout" do
-        result = WithString.process(:index)
+        result = WithString.new.process(:index)
         assert_equal "With String Hello string!", result.response_body
       end
       
       test "when layout is specified as a string, but the layout is missing, raise an exception" do
-        assert_raises(ActionView::MissingTemplate) { WithMissingLayout.process(:index) }
+        assert_raises(ActionView::MissingTemplate) { WithMissingLayout.new.process(:index) }
       end
       
       test "when layout is specified as false, do not use a layout" do
-        result = WithFalseLayout.process(:index)
+        result = WithFalseLayout.new.process(:index)
         assert_equal "Hello false!", result.response_body
       end
       
       test "when layout is specified as nil, do not use a layout" do
-        result = WithNilLayout.process(:index)
+        result = WithNilLayout.new.process(:index)
         assert_equal "Hello nil!", result.response_body
       end
       
       test "when layout is specified as a symbol, call the requested method and use the layout returned" do
-        result = WithSymbol.process(:index)
+        result = WithSymbol.new.process(:index)
         assert_equal "OMGHI2U Hello symbol!", result.response_body
       end
       
       test "when layout is specified as a symbol and the method returns nil, don't use a layout" do
-        result = WithSymbolReturningNil.process(:index)
+        result = WithSymbolReturningNil.new.process(:index)
         assert_equal "Hello nilz!", result.response_body
       end
       
       test "when the layout is specified as a symbol and the method doesn't exist, raise an exception" do
-        assert_raises(NoMethodError, /:nilz/) { WithSymbolAndNoMethod.process(:index) }
+        assert_raises(NoMethodError, /:nilz/) { WithSymbolAndNoMethod.new.process(:index) }
       end
       
       test "when the layout is specified as a symbol and the method returns something besides a string/false/nil, raise an exception" do
-        assert_raises(ArgumentError) { WithSymbolReturningObj.process(:index) }
+        assert_raises(ArgumentError) { WithSymbolReturningObj.new.process(:index) }
       end
       
       test "when a child controller does not have a layout, use the parent controller layout" do
-        result = WithStringChild.process(:index)
+        result = WithStringChild.new.process(:index)
         assert_equal "With String Hello string!", result.response_body
       end
       
       test "when a child controller has specified a layout, use that layout and not the parent controller layout" do
-        result = WithStringOverriddenChild.process(:index)
+        result = WithStringOverriddenChild.new.process(:index)
         assert_equal "With Override Hello string!", result.response_body
       end
       
       test "when a child controller has an implied layout, use that layout and not the parent controller layout" do
-        result = WithStringImpliedChild.process(:index)
+        result = WithStringImpliedChild.new.process(:index)
         assert_equal "With Implied Hello string!", result.response_body
       end
       
       test "when a child controller specifies layout nil, do not use the parent layout" do
-        result = WithNilChild.process(:index)
+        result = WithNilChild.new.process(:index)
         assert_equal "Hello string!", result.response_body
       end
             
       test "when a grandchild has no layout specified, the child has an implied layout, and the " \
         "parent has specified a layout, use the child controller layout" do
-          result = WithChildOfImplied.process(:index)
+          result = WithChildOfImplied.new.process(:index)
           assert_equal "With Implied Hello string!", result.response_body
       end
       
diff --git a/actionpack/test/controller/filters_test.rb b/actionpack/test/controller/filters_test.rb
index df0a9dbfb0..b930ff4997 100644
--- a/actionpack/test/controller/filters_test.rb
+++ b/actionpack/test/controller/filters_test.rb
@@ -876,10 +876,12 @@ class YieldingAroundFiltersTest < ActionController::TestCase
     assert_raise(After) { test_process(controller,'raises_after') }
   end
 
-  def test_with_method
-    controller = ControllerWithFilterMethod
-    assert_nothing_raised { test_process(controller,'no_raise') }
-    assert_raise(After) { test_process(controller,'raises_after') }
+  for_tag(:old_base) do
+    def test_with_method
+      controller = ControllerWithFilterMethod
+      assert_nothing_raised { test_process(controller,'no_raise') }
+      assert_raise(After) { test_process(controller,'raises_after') }
+    end
   end
 
   def test_with_proc
diff --git a/actionpack/test/controller/helper_test.rb b/actionpack/test/controller/helper_test.rb
index 5b9feb3630..342cbfbcd3 100644
--- a/actionpack/test/controller/helper_test.rb
+++ b/actionpack/test/controller/helper_test.rb
@@ -127,7 +127,7 @@ class HelperTest < Test::Unit::TestCase
   end
 
   def test_all_helpers
-    methods = AllHelpersController.master_helper_module.instance_methods.map(&:to_s)
+    methods = AllHelpersController.master_helper_module.instance_methods.map {|m| m.to_s}
 
     # abc_helper.rb
     assert methods.include?('bare_a')
@@ -171,11 +171,11 @@ class HelperTest < Test::Unit::TestCase
 
   private
     def expected_helper_methods
-      TestHelper.instance_methods.map(&:to_s)
+      TestHelper.instance_methods.map {|m| m.to_s }
     end
 
     def master_helper_methods
-      @controller_class.master_helper_module.instance_methods.map(&:to_s)
+      @controller_class.master_helper_module.instance_methods.map {|m| m.to_s }
     end
 
     def missing_methods
diff --git a/actionpack/test/controller/http_digest_authentication_test.rb b/actionpack/test/controller/http_digest_authentication_test.rb
index 15a11395bb..58f3b88075 100644
--- a/actionpack/test/controller/http_digest_authentication_test.rb
+++ b/actionpack/test/controller/http_digest_authentication_test.rb
@@ -76,6 +76,15 @@ class HttpDigestAuthenticationTest < ActionController::TestCase
     assert_equal 'SuperSecret', credentials[:realm]
   end
 
+  test "authentication request with nil credentials" do
+    @request.env['HTTP_AUTHORIZATION'] = encode_credentials(:username => nil, :password => nil)
+    get :index
+
+    assert_response :unauthorized
+    assert_equal "HTTP Digest: Access denied.\n", @response.body, "Authentication didn't fail for request"
+    assert_not_equal 'Hello Secret', @response.body, "Authentication didn't fail for request"
+  end
+
   test "authentication request with invalid password" do
     @request.env['HTTP_AUTHORIZATION'] = encode_credentials(:username => 'pretty', :password => 'foo')
     get :display
@@ -168,6 +177,11 @@ class HttpDigestAuthenticationTest < ActionController::TestCase
     assert_equal 'Definitely Maybe', @response.body
   end
 
+  test "validate_digest_response should fail with nil returning password_procedure" do
+    @request.env['HTTP_AUTHORIZATION'] = encode_credentials(:username => nil, :password => nil)
+    assert !ActionController::HttpAuthentication::Digest.validate_digest_response(@request, "SuperSecret"){nil}
+  end
+
   private
 
   def encode_credentials(options)
diff --git a/actionpack/test/controller/routing_test.rb b/actionpack/test/controller/routing_test.rb
index 6b08a04b10..c2acc03a1b 100644
--- a/actionpack/test/controller/routing_test.rb
+++ b/actionpack/test/controller/routing_test.rb
@@ -1623,13 +1623,13 @@ class RouteSetTest < Test::Unit::TestCase
     set.draw { |m| m.connect ':controller/:action/:id' }
     path, extras = set.generate_extras(:controller => "foo", :action => "bar", :id => 15, :this => "hello", :that => "world")
     assert_equal "/foo/bar/15", path
-    assert_equal %w(that this), extras.map(&:to_s).sort
+    assert_equal %w(that this), extras.map { |e| e.to_s }.sort
   end
 
   def test_extra_keys
     set.draw { |m| m.connect ':controller/:action/:id' }
     extras = set.extra_keys(:controller => "foo", :action => "bar", :id => 15, :this => "hello", :that => "world")
-    assert_equal %w(that this), extras.map(&:to_s).sort
+    assert_equal %w(that this), extras.map { |e| e.to_s }.sort
   end
 
   def test_generate_extras_not_first
@@ -1639,7 +1639,7 @@ class RouteSetTest < Test::Unit::TestCase
     end
     path, extras = set.generate_extras(:controller => "foo", :action => "bar", :id => 15, :this => "hello", :that => "world")
     assert_equal "/foo/bar/15", path
-    assert_equal %w(that this), extras.map(&:to_s).sort
+    assert_equal %w(that this), extras.map { |e| e.to_s }.sort
   end
 
   def test_generate_not_first
@@ -1656,7 +1656,7 @@ class RouteSetTest < Test::Unit::TestCase
       map.connect ':controller/:action/:id'
     end
     extras = set.extra_keys(:controller => "foo", :action => "bar", :id => 15, :this => "hello", :that => "world")
-    assert_equal %w(that this), extras.map(&:to_s).sort
+    assert_equal %w(that this), extras.map { |e| e.to_s }.sort
   end
 
   def test_draw
diff --git a/actionpack/test/dispatch/mime_type_test.rb b/actionpack/test/dispatch/mime_type_test.rb
index 2fdf4819bb..27bdd10ee5 100644
--- a/actionpack/test/dispatch/mime_type_test.rb
+++ b/actionpack/test/dispatch/mime_type_test.rb
@@ -56,7 +56,7 @@ class MimeTypeTest < ActiveSupport::TestCase
 
   test "type convenience methods" do
     # Don't test Mime::ALL, since it Mime::ALL#html? == true
-    types = Mime::SET.to_a.map(&:to_sym).uniq - [:all]
+    types = Mime::SET.to_a.map{|m| m.to_sym }.uniq - [:all]
 
     # Remove custom Mime::Type instances set in other tests, like Mime::GIF and Mime::IPHONE
     types.delete_if { |type| !Mime.const_defined?(type.to_s.upcase) }
@@ -76,7 +76,7 @@ class MimeTypeTest < ActiveSupport::TestCase
   end
 
   test "verifiable mime types" do
-    all_types = Mime::SET.to_a.map(&:to_sym)
+    all_types = Mime::SET.to_a.map{|m| m.to_sym}
     all_types.uniq!
     # Remove custom Mime::Type instances set in other tests, like Mime::GIF and Mime::IPHONE
     all_types.delete_if { |type| !Mime.const_defined?(type.to_s.upcase) }
diff --git a/actionpack/test/fixtures/test/_local_inspector.html.erb b/actionpack/test/fixtures/test/_local_inspector.html.erb
index c5a6e3e5bc..e6765c0882 100644
--- a/actionpack/test/fixtures/test/_local_inspector.html.erb
+++ b/actionpack/test/fixtures/test/_local_inspector.html.erb
@@ -1 +1 @@
-<%= local_assigns.keys.map(&:to_s).sort.join(",") -%>
\ No newline at end of file
+<%= local_assigns.keys.map {|k| k.to_s }.sort.join(",") -%>
\ No newline at end of file
diff --git a/actionpack/test/new_base/abstract_unit.rb b/actionpack/test/new_base/abstract_unit.rb
index e6690d41d9..7d72f8393b 100644
--- a/actionpack/test/new_base/abstract_unit.rb
+++ b/actionpack/test/new_base/abstract_unit.rb
@@ -11,9 +11,6 @@ $stderr.puts "Running old tests on new_base"
 require 'test/unit'
 require 'active_support'
 
-# TODO : Revisit requiring all the core extensions here
-require 'active_support/core_ext'
-
 require 'active_support/test_case'
 require 'action_controller/abstract'
 require 'action_controller/new_base'
@@ -45,6 +42,16 @@ ORIGINAL_LOCALES = I18n.available_locales.map {|locale| locale.to_s }.sort
 
 FIXTURE_LOAD_PATH = File.join(File.dirname(__FILE__), '../fixtures')
 
+module ActionView
+  class TestCase
+    setup do
+      ActionController::Routing::Routes.draw do |map|
+        map.connect ':controller/:action/:id'
+      end
+    end
+  end
+end
+
 module ActionController
   Base.session = {
   :key         => '_testing_session',
diff --git a/actionpack/test/template/erb_util_test.rb b/actionpack/test/template/erb_util_test.rb
index c8c986f218..49f51c50c5 100644
--- a/actionpack/test/template/erb_util_test.rb
+++ b/actionpack/test/template/erb_util_test.rb
@@ -16,7 +16,7 @@ class ErbUtilTest < Test::Unit::TestCase
   end
   
   def test_rest_in_ascii
-    (0..127).to_a.map(&:chr).each do |chr|
+    (0..127).to_a.map {|int| int.chr }.each do |chr|
       next if %w(& " < >).include?(chr)
       assert_equal chr, html_escape(chr)
     end
diff --git a/actionpack/test/template/form_helper_test.rb b/actionpack/test/template/form_helper_test.rb
index 104649deac..947668ccc6 100644
--- a/actionpack/test/template/form_helper_test.rb
+++ b/actionpack/test/template/form_helper_test.rb
@@ -99,6 +99,11 @@ class FormHelperTest < ActionView::TestCase
     assert_dom_equal('<label for="my_for">Title</label>', label(:post, :title, nil, "for" => "my_for"))
   end
 
+  def test_label_for_radio_buttons_with_value
+    assert_dom_equal('<label for="post_title_great_title">The title goes here</label>', label("post", "title", "The title goes here", :value => "great_title"))
+    assert_dom_equal('<label for="post_title_great_title">The title goes here</label>', label("post", "title", "The title goes here", :value => "great title"))
+  end
+
   def test_text_field
     assert_dom_equal(
       '<input id="post_title" name="post[title]" size="30" type="text" value="Hello World" />', text_field("post", "title")
@@ -532,6 +537,20 @@ class FormHelperTest < ActionView::TestCase
     assert_dom_equal expected, output_buffer
   end
 
+  def test_nested_fields_for_with_index_radio_button
+    form_for(:post, @post) do |f|
+      f.fields_for(:comment, @post, :index => 5) do |c|
+        concat c.radio_button(:title, "hello")
+      end
+    end
+
+    expected = "<form action='http://www.example.com' method='post'>" +
+               "<input name='post[comment][5][title]' type='radio' id='post_comment_5_title_hello' value='hello' />" +
+               "</form>"
+
+    assert_dom_equal expected, output_buffer
+  end
+
   def test_nested_fields_for_with_auto_index_on_both
     form_for("post[]", @post) do |f|
       f.fields_for("comment[]", @post) do |c|
diff --git a/actionpack/test/template/form_tag_helper_test.rb b/actionpack/test/template/form_tag_helper_test.rb
index 5ca4d4d6ea..09d199b75d 100644
--- a/actionpack/test/template/form_tag_helper_test.rb
+++ b/actionpack/test/template/form_tag_helper_test.rb
@@ -154,6 +154,11 @@ class FormTagHelperTest < ActionView::TestCase
     assert_dom_equal expected, actual
   end
 
+  def test_text_area_tag_id_sanitized
+    input_elem = root_elem(text_area_tag("item[][description]"))
+    assert_match VALID_HTML_ID, input_elem['id']
+  end
+
   def test_text_field_tag
     actual = text_field_tag "title", "Hello!"
     expected = %(<input id="title" name="title" type="text" value="Hello!" />)
diff --git a/actionpack/test/template/number_helper_test.rb b/actionpack/test/template/number_helper_test.rb
index b6542ef29d..57b740032e 100644
--- a/actionpack/test/template/number_helper_test.rb
+++ b/actionpack/test/template/number_helper_test.rb
@@ -3,6 +3,22 @@ require 'abstract_unit'
 class NumberHelperTest < ActionView::TestCase
   tests ActionView::Helpers::NumberHelper
 
+  def kilobytes(number)
+    number * 1024
+  end
+
+  def megabytes(number)
+    kilobytes(number) * 1024
+  end
+
+  def gigabytes(number)
+    megabytes(number) * 1024
+  end
+
+  def terabytes(number)
+    gigabytes(number) * 1024
+  end
+
   def test_number_to_phone
     assert_equal("555-1234", number_to_phone(5551234))
     assert_equal("800-555-1212", number_to_phone(8005551212))
@@ -96,16 +112,16 @@ class NumberHelperTest < ActionView::TestCase
     assert_equal '1.2 MB',    number_to_human_size(1234567)
     assert_equal '1.1 GB',    number_to_human_size(1234567890)
     assert_equal '1.1 TB',    number_to_human_size(1234567890123)
-    assert_equal '1025 TB',   number_to_human_size(1025.terabytes)
-    assert_equal '444 KB',    number_to_human_size(444.kilobytes)
-    assert_equal '1023 MB',   number_to_human_size(1023.megabytes)
-    assert_equal '3 TB',      number_to_human_size(3.terabytes)
+    assert_equal '1025 TB',   number_to_human_size(terabytes(1025))
+    assert_equal '444 KB',    number_to_human_size(kilobytes(444))
+    assert_equal '1023 MB',   number_to_human_size(megabytes(1023))
+    assert_equal '3 TB',      number_to_human_size(terabytes(3))
     assert_equal '1.18 MB',   number_to_human_size(1234567, :precision => 2)
     assert_equal '3 Bytes',   number_to_human_size(3.14159265, :precision => 4)
     assert_equal("123 Bytes", number_to_human_size("123"))
-    assert_equal '1.01 KB',   number_to_human_size(1.0123.kilobytes, :precision => 2)
-    assert_equal '1.01 KB',   number_to_human_size(1.0100.kilobytes, :precision => 4)
-    assert_equal '10 KB',   number_to_human_size(10.000.kilobytes, :precision => 4)
+    assert_equal '1.01 KB',   number_to_human_size(kilobytes(1.0123), :precision => 2)
+    assert_equal '1.01 KB',   number_to_human_size(kilobytes(1.0100), :precision => 4)
+    assert_equal '10 KB',   number_to_human_size(kilobytes(10.000), :precision => 4)
     assert_equal '1 Byte',   number_to_human_size(1.1)
     assert_equal '10 Bytes', number_to_human_size(10)
     #assert_nil number_to_human_size('x') # fails due to API consolidation
@@ -115,9 +131,9 @@ class NumberHelperTest < ActionView::TestCase
   def test_number_to_human_size_with_options_hash
     assert_equal '1.18 MB',   number_to_human_size(1234567, :precision => 2)
     assert_equal '3 Bytes',   number_to_human_size(3.14159265, :precision => 4)
-    assert_equal '1.01 KB',   number_to_human_size(1.0123.kilobytes, :precision => 2)
-    assert_equal '1.01 KB',   number_to_human_size(1.0100.kilobytes, :precision => 4)
-    assert_equal '10 KB',     number_to_human_size(10.000.kilobytes, :precision => 4)
+    assert_equal '1.01 KB',   number_to_human_size(kilobytes(1.0123), :precision => 2)
+    assert_equal '1.01 KB',   number_to_human_size(kilobytes(1.0100), :precision => 4)
+    assert_equal '10 KB',     number_to_human_size(kilobytes(10.000), :precision => 4)
     assert_equal '1 TB', number_to_human_size(1234567890123, :precision => 0)
     assert_equal '500 MB', number_to_human_size(524288000, :precision=>0)
     assert_equal '40 KB', number_to_human_size(41010, :precision => 0)
@@ -125,8 +141,8 @@ class NumberHelperTest < ActionView::TestCase
   end
 
   def test_number_to_human_size_with_custom_delimiter_and_separator
-    assert_equal '1,01 KB',     number_to_human_size(1.0123.kilobytes, :precision => 2, :separator => ',')
-    assert_equal '1,01 KB',     number_to_human_size(1.0100.kilobytes, :precision => 4, :separator => ',')
-    assert_equal '1.000,1 TB',  number_to_human_size(1000.1.terabytes, :delimiter => '.', :separator => ',')
+    assert_equal '1,01 KB',     number_to_human_size(kilobytes(1.0123), :precision => 2, :separator => ',')
+    assert_equal '1,01 KB',     number_to_human_size(kilobytes(1.0100), :precision => 4, :separator => ',')
+    assert_equal '1.000,1 TB',  number_to_human_size(terabytes(1000.1), :delimiter => '.', :separator => ',')
   end
 end
diff --git a/actionpack/test/template/render_test.rb b/actionpack/test/template/render_test.rb
index 20cd4cc1d4..2ed11aa3c0 100644
--- a/actionpack/test/template/render_test.rb
+++ b/actionpack/test/template/render_test.rb
@@ -13,7 +13,7 @@ module RenderTestCases
     I18n.backend.store_translations 'pt-BR', {}
 
     # Ensure original are still the same since we are reindexing view paths
-    assert_equal ORIGINAL_LOCALES, I18n.available_locales.map(&:to_s).sort
+    assert_equal ORIGINAL_LOCALES, I18n.available_locales.map {|l| l.to_s }.sort
   end
 
   def test_render_file