actionpack 1.9.0 → 1.9.1

data/lib/action_view/helpers/tag_helper.rb

@@ -24,8 +24,9 @@ module ActionView
 
       private
         def tag_options(options)
-          unless options.empty?
-            " " + options.symbolize_keys.map { |key, value|
+          cleaned_options = options.reject { |key, value| value.nil? }
+          unless cleaned_options.empty?
+            " " + cleaned_options.symbolize_keys.map { |key, value|
               %(#{key}="#{html_escape(value.to_s)}")
             }.sort.join(" ")
           end

data/lib/action_view/helpers/text_helper.rb

@@ -113,7 +113,7 @@ module ActionView
         text.gsub!(/\n\n/, '</p>\0<p>') # turn two newlines into paragraph
         text.gsub!(/([^\n])(\n)([^\n])/, '\1\2<br />\3') # turn single newline into <br />
         
-        return '<p>' + text + '</p>' # wrap the first and last line in paragraphs before we're done
+        content_tag("p", text)
       end
 
       # Turns all urls and email addresses into clickable links. The +link+ parameter can limit what should be linked.

data/lib/action_view/helpers/url_helper.rb

@@ -143,7 +143,7 @@ module ActionView
           if block_given?
             block.arity <= 1 ? yield(name) : yield(name, options, html_options, *parameters_for_method_reference)
           else
-            html_escape(name)
+            name
           end
         else
           link_to(name, options, html_options, *parameters_for_method_reference)

data/rakefile

@@ -8,7 +8,7 @@ require 'rake/contrib/rubyforgepublisher'
 
 PKG_BUILD     = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
 PKG_NAME      = 'actionpack'
-PKG_VERSION   = '1.9.0' + PKG_BUILD
+PKG_VERSION   = '1.9.1' + PKG_BUILD
 PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
 
 RELEASE_NAME  = "REL #{PKG_VERSION}"
@@ -61,7 +61,7 @@ spec = Gem::Specification.new do |s|
   s.has_rdoc = true
   s.requirements << 'none'
 
-  s.add_dependency('activesupport', '= 1.1.0' + PKG_BUILD)
+  s.add_dependency('activesupport', '= 1.1.1' + PKG_BUILD)
 
   s.require_path = 'lib'
   s.autorequire = 'action_controller'

data/test/controller/active_record_store_test.rb

@@ -18,8 +18,14 @@ begin
   CGI::Session::ActiveRecordStore::Session.establish_connection(:adapter => 'sqlite3', :dbfile => ':memory:')
   CGI::Session::ActiveRecordStore::Session.connection
 rescue Object
-  $stderr.puts 'SQLite 3 unavailable; falling to SQLite 2.'
-  CGI::Session::ActiveRecordStore::Session.establish_connection(:adapter => 'sqlite', :dbfile => ':memory:')
+  $stderr.puts 'SQLite 3 unavailable; falling back to SQLite 2.'
+  begin
+    CGI::Session::ActiveRecordStore::Session.establish_connection(:adapter => 'sqlite', :dbfile => ':memory:')
+    CGI::Session::ActiveRecordStore::Session.connection
+  rescue Object
+    $stderr.puts 'SQLite 2 unavailable; skipping ActiveRecordStore test suite.'
+    raise SystemExit
+  end
 end
 
 
@@ -27,7 +33,7 @@ module CommonActiveRecordStoreTests
   def test_basics
     s = session_class.new(:session_id => '1234', :data => { 'foo' => 'bar' })
     assert_equal 'bar', s.data['foo']
-    assert s.save!
+    assert s.save
     assert_equal 'bar', s.data['foo']
 
     assert_not_nil t = session_class.find_by_session_id('1234')

data/test/controller/filters_test.rb

@@ -203,6 +203,18 @@ class FilterTest < Test::Unit::TestCase
       end
   end
 
+  class DynamicDispatchController < ActionController::Base
+    before_filter :choose
+
+    %w(foo bar baz).each do |action|
+      define_method(action) { render :text => action }
+    end
+
+    private
+      def choose
+        self.action_name = params[:choose]
+      end
+  end
 
   def test_added_filter_to_inheritance_graph
     assert_equal [ :fire_flash, :ensure_login ], TestController.before_filters
@@ -321,6 +333,15 @@ class FilterTest < Test::Unit::TestCase
     end
   end
 
+  def test_dynamic_dispatch
+    %w(foo bar baz).each do |action|
+      request = ActionController::TestRequest.new
+      request.query_parameters[:choose] = action
+      response = DynamicDispatchController.process(request, ActionController::TestResponse.new)
+      assert_equal action, response.body
+    end
+  end
+
   private
     def test_process(controller, action = "show")
       request = ActionController::TestRequest.new

data/test/controller/new_render_test.rb

@@ -99,6 +99,21 @@ class NewRenderTestController < ActionController::Base
     render "test/hello_world"
   end
 
+  def double_render
+    render :text => "hello"
+    render :text => "world"
+  end
+
+  def double_redirect
+    redirect_to :action => "double_render"
+    redirect_to :action => "double_render"
+  end
+
+  def render_and_redirect
+    render :text => "hello"
+    redirect_to :action => "double_render"
+  end
+
   def rescue_action(e) raise end
     
   private
@@ -260,4 +275,16 @@ class NewRenderTest < Test::Unit::TestCase
     get :render_with_explicit_template
     assert_response :success
   end
+
+  def test_double_render
+    assert_raises(ActionController::DoubleRenderError) { get :double_render }
+  end
+
+  def test_double_redirect
+    assert_raises(ActionController::DoubleRenderError) { get :double_redirect }
+  end
+
+  def test_render_and_redirect
+    assert_raises(ActionController::DoubleRenderError) { get :render_and_redirect }
+  end
 end

data/test/controller/routing_test.rb

@@ -109,6 +109,9 @@ module Object::Controllers
     
     class UserController
     end
+
+    class NewsFeedController
+    end
   end
 end
 
@@ -661,7 +664,17 @@ class RouteSetTests < Test::Unit::TestCase
     x = setup_for_named_route
     assert_equal({:controller => '/content', :action => 'show_page', :title => 'new stuff'},
                  x.new.send(:page_url, :title => 'new stuff'))
-  end  
+  end
+
+  def test_named_route_with_default
+    rs.page 'page/:title', :controller => 'content', :action => 'show_page', :title => 'AboutPage'
+    x = setup_for_named_route
+    assert_equal({:controller => '/content', :action => 'show_page', :title => 'AboutPage'},
+                 x.new.send(:page_url))
+    assert_equal({:controller => '/content', :action => 'show_page', :title => 'AboutRails'},
+                 x.new.send(:page_url, :title => "AboutRails"))
+
+  end
 
   def setup_for_named_route
     x = Class.new
@@ -683,6 +696,35 @@ class RouteSetTests < Test::Unit::TestCase
     )
   end  
 
+  def test_paths_escaped
+    rs.draw do |map|
+      rs.path 'file/*path', :controller => 'content', :action => 'show_file'
+      rs.connect ':controller/:action/:id'
+    end
+    
+    results = rs.recognize_path %w(file hello+world how+are+you%3F)
+    assert results, "Recognition should have succeeded"
+    assert_equal ['hello world', 'how are you?'], results['path']
+
+    results = rs.recognize_path %w(file)
+    assert results, "Recognition should have succeeded"
+    assert_equal [], results['path']
+  end
+
+  def test_paths_do_not_accept_defaults
+    assert_raises(ActionController::RoutingError) do
+      rs.draw do |map|
+        rs.path 'file/*path', :controller => 'content', :action => 'show_file', :path => %w(fake default)
+        rs.connect ':controller/:action/:id'
+      end
+    end
+    
+    rs.draw do |map|
+      rs.path 'file/*path', :controller => 'content', :action => 'show_file', :path => []
+      rs.connect ':controller/:action/:id'
+    end
+  end
+  
   def test_backwards
     rs.draw do |map|
       rs.connect 'page/:id/:action', :controller => 'pages', :action => 'show'
@@ -694,9 +736,36 @@ class RouteSetTests < Test::Unit::TestCase
     assert_equal ['/pages/boo', {}], rs.generate(:controller => 'pages', :action => 'boo')
   end
 
+  def test_route_with_fixnum_default
+    rs.draw do |map|
+      rs.connect 'page/:id', :controller => 'content', :action => 'show_page', :id => 1
+      rs.connect ':controller/:action/:id'
+    end
+
+    assert_equal ['/page', {}], rs.generate(:controller => 'content', :action => 'show_page')
+    assert_equal ['/page', {}], rs.generate(:controller => 'content', :action => 'show_page', :id => 1)
+    assert_equal ['/page', {}], rs.generate(:controller => 'content', :action => 'show_page', :id => '1')
+    assert_equal ['/page/10', {}], rs.generate(:controller => 'content', :action => 'show_page', :id => 10)
+
+    ctrl = ::Controllers::ContentController
+
+    assert_equal({'controller' => ctrl, 'action' => 'show_page', 'id' => 1}, rs.recognize_path(%w(page)))
+    assert_equal({'controller' => ctrl, 'action' => 'show_page', 'id' => '1'}, rs.recognize_path(%w(page 1)))
+    assert_equal({'controller' => ctrl, 'action' => 'show_page', 'id' => '10'}, rs.recognize_path(%w(page 10)))
+  end
+
   def test_action_expiry
     assert_equal ['/content', {}], rs.generate({:controller => 'content'}, {:controller => 'content', :action => 'show'})
   end
+
+  def test_recognition_with_uppercase_controller_name
+    assert_equal({'controller' => ::Controllers::ContentController, 'action' => 'index'}, rs.recognize_path(%w(Content)))
+    assert_equal({'controller' => ::Controllers::ContentController, 'action' => 'list'}, rs.recognize_path(%w(Content list)))
+    assert_equal({'controller' => ::Controllers::ContentController, 'action' => 'show', 'id' => '10'}, rs.recognize_path(%w(Content show 10)))
+
+    assert_equal({'controller' => ::Controllers::Admin::NewsFeedController, 'action' => 'index'}, rs.recognize_path(%w(Admin NewsFeed)))
+    assert_equal({'controller' => ::Controllers::Admin::NewsFeedController, 'action' => 'index'}, rs.recognize_path(%w(Admin News_Feed)))
+  end
 end
 
 end

data/test/controller/test_test.rb

@@ -114,10 +114,44 @@ HTML
     )
   end
 
-  def test_path_params_are_strings
+  def test_id_converted_to_string
     get :test_params, :id => 20, :foo => Object.new
-    @request.path_parameters.each do |key, value|
-      assert_kind_of String, value
+    assert_kind_of String, @request.path_parameters['id']
+  end
+
+  def test_array_path_parameter_handled_properly
+    with_routing do |set|
+      set.draw do 
+        set.connect 'file/*path', :controller => 'test_test/test', :action => 'test_params'
+        set.connect ':controller/:action/:id'
+      end
+      
+      get :test_params, :path => ['hello', 'world']
+      assert_equal ['hello', 'world'], @request.path_parameters['path']
+      assert_equal 'hello/world', @request.path_parameters['path'].to_s
+    end
+  end
+
+  def test_assert_realistic_path_parameters
+    get :test_params, :id => 20, :foo => Object.new
+
+    # All elements of path_parameters should use string keys
+    @request.path_parameters.keys.each do |key|
+      assert_kind_of String, key
+    end
+  end
+
+  def test_with_routing_places_routes_back
+    assert ActionController::Routing::Routes
+    routes_id = ActionController::Routing::Routes.object_id
+    
+    begin
+      with_routing { raise 'fail' }
+      fail 'Should not be here.'
+    rescue RuntimeError
     end
+    
+    assert ActionController::Routing::Routes
+    assert_equal routes_id, ActionController::Routing::Routes.object_id
   end
 end

data/test/template/form_helper_test.rb

@@ -37,7 +37,7 @@ class FormHelperTest < Test::Unit::TestCase
       '<input id="post_title" name="post[title]" size="30" type="password" value="Hello World" />', password_field("post", "title")
     )
     assert_equal(
-      '<input id="person_name" name="person[name]" size="30" type="password" value="" />', password_field("person", "name")
+      '<input id="person_name" name="person[name]" size="30" type="password" />', password_field("person", "name")
     )
   end
 
@@ -71,7 +71,7 @@ class FormHelperTest < Test::Unit::TestCase
       check_box("post", "secret")
     )
     assert_equal(
-      '<input checked="checked" id="post_secret" name="post[secret]" type="checkbox" value="1" /><input name="post[secret]" type="hidden" value="0" />', 
+      '<input checked="checked" id="post_secret" name="post[secret]" type="checkbox" value="1" /><input name="post[secret]" type="hidden" value="0" />',
       check_box("post", "secret" ,{"checked"=>"checked"})
     )
     @post.secret = true
@@ -80,7 +80,7 @@ class FormHelperTest < Test::Unit::TestCase
       check_box("post", "secret")
     )
   end
-  
+
   def test_check_box_with_explicit_checked_and_unchecked_values
     @post.secret = "on"
     assert_equal(

data/test/template/form_tag_helper_test.rb

@@ -22,7 +22,7 @@ class FormTagHelperTest < Test::Unit::TestCase
   end
 
   def test_form_tag
-    actual = form_tag 
+    actual = form_tag
     expected = %(<form action="http://www.example.com" method="post">)
     assert_equal expected, actual
   end
@@ -41,7 +41,7 @@ class FormTagHelperTest < Test::Unit::TestCase
 
   def test_password_field_tag
     actual = password_field_tag
-    expected = %(<input id="password" name="password" type="password" value="" />)
+    expected = %(<input id="password" name="password" type="password" />)
     assert_equal expected, actual
   end
 

data/test/template/{javascript_helper.rb → javascript_helper_test.rb}

@@ -35,46 +35,50 @@ class JavaScriptHelperTest < Test::Unit::TestCase
   end
   
   def test_link_to_remote
-    assert_equal %(<a class=\"fine\" href=\"#\" onclick=\"new Ajax.Request('http://www.example.com/whatnot', {evalScripts:true, asynchronous:true}); return false;\">Remote outpost</a>),
+    assert_equal %(<a class=\"fine\" href=\"#\" onclick=\"new Ajax.Request('http://www.example.com/whatnot', {asynchronous:true, evalScripts:true}); return false;\">Remote outpost</a>),
       link_to_remote("Remote outpost", { :url => { :action => "whatnot"  }}, { :class => "fine"  })
-    assert_equal %(<a href=\"#\" onclick=\"new Ajax.Request('http://www.example.com/whatnot', {onComplete:function(request){alert(request.reponseText)}, evalScripts:true, asynchronous:true}); return false;\">Remote outpost</a>),
+    assert_equal %(<a href=\"#\" onclick=\"new Ajax.Request('http://www.example.com/whatnot', {asynchronous:true, evalScripts:true, onComplete:function(request){alert(request.reponseText)}}); return false;\">Remote outpost</a>),
       link_to_remote("Remote outpost", :complete => "alert(request.reponseText)", :url => { :action => "whatnot"  })
   end
   
   def test_periodically_call_remote
-    assert_equal %(<script>new PeriodicalExecuter(function() {new Ajax.Updater('schremser_bier', 'http://www.example.com/mehr_bier', {evalScripts:true, asynchronous:true})}, 10)</script>),
+    assert_equal %(<script>new PeriodicalExecuter(function() {new Ajax.Updater('schremser_bier', 'http://www.example.com/mehr_bier', {asynchronous:true, evalScripts:true})}, 10)</script>),
       periodically_call_remote(:update => "schremser_bier", :url => { :action => "mehr_bier" })
   end
   
   def test_form_remote_tag
-    assert_equal %(<form action=\"http://www.example.com/fast\" method=\"post\" onsubmit=\"new Ajax.Updater('glass_of_beer', 'http://www.example.com/fast', {parameters:Form.serialize(this), evalScripts:true, asynchronous:true}); return false;\">),
+    assert_equal %(<form action=\"http://www.example.com/fast\" method=\"post\" onsubmit=\"new Ajax.Updater('glass_of_beer', 'http://www.example.com/fast', {asynchronous:true, evalScripts:true, parameters:Form.serialize(this)}); return false;\">),
       form_remote_tag(:update => "glass_of_beer", :url => { :action => :fast  })
-    assert_equal %(<form action=\"http://www.example.com/fast\" method=\"post\" onsubmit=\"new Ajax.Updater({success:'glass_of_beer'}, 'http://www.example.com/fast', {parameters:Form.serialize(this), evalScripts:true, asynchronous:true}); return false;\">),
+    assert_equal %(<form action=\"http://www.example.com/fast\" method=\"post\" onsubmit=\"new Ajax.Updater({success:'glass_of_beer'}, 'http://www.example.com/fast', {asynchronous:true, evalScripts:true, parameters:Form.serialize(this)}); return false;\">),
       form_remote_tag(:update => { :success => "glass_of_beer" }, :url => { :action => :fast  })
-    assert_equal %(<form action=\"http://www.example.com/fast\" method=\"post\" onsubmit=\"new Ajax.Updater({failure:'glass_of_water'}, 'http://www.example.com/fast', {parameters:Form.serialize(this), evalScripts:true, asynchronous:true}); return false;\">),
+    assert_equal %(<form action=\"http://www.example.com/fast\" method=\"post\" onsubmit=\"new Ajax.Updater({failure:'glass_of_water'}, 'http://www.example.com/fast', {asynchronous:true, evalScripts:true, parameters:Form.serialize(this)}); return false;\">),
       form_remote_tag(:update => { :failure => "glass_of_water" }, :url => { :action => :fast  })
-    assert_equal %(<form action=\"http://www.example.com/fast\" method=\"post\" onsubmit=\"new Ajax.Updater({success:'glass_of_beer',failure:'glass_of_water'}, 'http://www.example.com/fast', {parameters:Form.serialize(this), evalScripts:true, asynchronous:true}); return false;\">),
+    assert_equal %(<form action=\"http://www.example.com/fast\" method=\"post\" onsubmit=\"new Ajax.Updater({success:'glass_of_beer',failure:'glass_of_water'}, 'http://www.example.com/fast', {asynchronous:true, evalScripts:true, parameters:Form.serialize(this)}); return false;\">),
       form_remote_tag(:update => { :success => 'glass_of_beer', :failure => "glass_of_water" }, :url => { :action => :fast  })
   end
   
   def test_submit_to_remote
-    assert_equal %(<input name=\"More beer!\" onclick=\"new Ajax.Updater('empty_bottle', 'http://www.example.com/', {parameters:Form.serialize(this.form), evalScripts:true, asynchronous:true}); return false;\" type=\"button\" value=\"1000000\" />),
+    assert_equal %(<input name=\"More beer!\" onclick=\"new Ajax.Updater('empty_bottle', 'http://www.example.com/', {asynchronous:true, evalScripts:true, parameters:Form.serialize(this.form)}); return false;\" type=\"button\" value=\"1000000\" />),
       submit_to_remote("More beer!", 1_000_000, :update => "empty_bottle")
   end
   
   def test_observe_field
-    assert_equal %(<script type=\"text/javascript\">new Form.Element.Observer('glass', 300, function(element, value) {new Ajax.Request('http://www.example.com/reorder_if_empty', {evalScripts:true, asynchronous:true})})</script>),
+    assert_equal %(<script type=\"text/javascript\">new Form.Element.Observer('glass', 300, function(element, value) {new Ajax.Request('http://www.example.com/reorder_if_empty', {asynchronous:true, evalScripts:true})})</script>),
       observe_field("glass", :frequency => 5.minutes, :url => { :action => "reorder_if_empty" })
   end
   
   def test_observe_form
-    assert_equal %(<script type=\"text/javascript\">new Form.Observer('cart', 2, function(element, value) {new Ajax.Request('http://www.example.com/cart_changed', {evalScripts:true, asynchronous:true})})</script>),
+    assert_equal %(<script type=\"text/javascript\">new Form.Observer('cart', 2, function(element, value) {new Ajax.Request('http://www.example.com/cart_changed', {asynchronous:true, evalScripts:true})})</script>),
       observe_form("cart", :frequency => 2, :url => { :action => "cart_changed" })
   end
   
   def test_auto_complete_field
     assert_equal %(<script type=\"text/javascript\">new Ajax.Autocompleter('some_input', 'some_input_auto_complete', 'http://www.example.com/autocomplete', {})</script>),
-      auto_complete_field("some_input", :url => { :action => "autocomplete" });    
+      auto_complete_field("some_input", :url => { :action => "autocomplete" });
+    assert_equal %(<script type=\"text/javascript\">new Ajax.Autocompleter('some_input', 'some_input_auto_complete', 'http://www.example.com/autocomplete', {tokens:','})</script>),
+      auto_complete_field("some_input", :url => { :action => "autocomplete" }, :tokens => ',');
+    assert_equal %(<script type=\"text/javascript\">new Ajax.Autocompleter('some_input', 'some_input_auto_complete', 'http://www.example.com/autocomplete', {tokens:[',']})</script>),
+      auto_complete_field("some_input", :url => { :action => "autocomplete" }, :tokens => [',']);  
   end
   
   def test_auto_complete_result
@@ -88,7 +92,7 @@ class JavaScriptHelperTest < Test::Unit::TestCase
   def test_text_field_with_auto_complete
     assert_match "<style>",
       text_field_with_auto_complete(:message, :recipient)
-    assert_equal %(<input autocomplete=\"off\" id=\"message_recipient\" name=\"message[recipient]\" size=\"30\" type=\"text\" value=\"\" /><div class=\"auto_complete\" id=\"message_recipient_auto_complete\"></div><script type=\"text/javascript\">new Ajax.Autocompleter('message_recipient', 'message_recipient_auto_complete', 'http://www.example.com/auto_complete_for_message_recipient', {})</script>),
+    assert_equal %(<input autocomplete=\"off\" id=\"message_recipient\" name=\"message[recipient]\" size=\"30\" type=\"text\" /><div class=\"auto_complete\" id=\"message_recipient_auto_complete\"></div><script type=\"text/javascript\">new Ajax.Autocompleter('message_recipient', 'message_recipient_auto_complete', 'http://www.example.com/auto_complete_for_message_recipient', {})</script>),
       text_field_with_auto_complete(:message, :recipient, {}, :skip_style => true)
   end
   
@@ -101,13 +105,13 @@ class JavaScriptHelperTest < Test::Unit::TestCase
   end
   
   def test_sortable_element
-    assert_equal %(<script type=\"text/javascript\">Sortable.create('mylist', {onUpdate:function(){new Ajax.Request('http://www.example.com/order', {parameters:Sortable.serialize('mylist'), evalScripts:true, asynchronous:true})}})</script>), 
+    assert_equal %(<script type=\"text/javascript\">Sortable.create('mylist', {onUpdate:function(){new Ajax.Request('http://www.example.com/order', {asynchronous:true, evalScripts:true, parameters:Sortable.serialize('mylist')})}})</script>), 
       sortable_element("mylist", :url => { :action => "order" })
-    assert_equal %(<script type=\"text/javascript\">Sortable.create('mylist', {tag:'div', constraint:'horizontal', onUpdate:function(){new Ajax.Request('http://www.example.com/order', {parameters:Sortable.serialize('mylist'), evalScripts:true, asynchronous:true})}})</script>), 
+    assert_equal %(<script type=\"text/javascript\">Sortable.create('mylist', {constraint:'horizontal', onUpdate:function(){new Ajax.Request('http://www.example.com/order', {asynchronous:true, evalScripts:true, parameters:Sortable.serialize('mylist')})}, tag:'div'})</script>), 
       sortable_element("mylist", :tag => "div", :constraint => "horizontal", :url => { :action => "order" })
-    assert_equal %(<script type=\"text/javascript\">Sortable.create('mylist', {constraint:'horizontal', containment:['list1','list2'], onUpdate:function(){new Ajax.Request('http://www.example.com/order', {parameters:Sortable.serialize('mylist'), evalScripts:true, asynchronous:true})}})</script>), 
+    assert_equal %|<script type=\"text/javascript\">Sortable.create('mylist', {constraint:'horizontal', containment:['list1','list2'], onUpdate:function(){new Ajax.Request('http://www.example.com/order', {asynchronous:true, evalScripts:true, parameters:Sortable.serialize('mylist')})}})</script>|, 
       sortable_element("mylist", :containment => ['list1','list2'], :constraint => "horizontal", :url => { :action => "order" })
-    assert_equal %(<script type=\"text/javascript\">Sortable.create('mylist', {constraint:'horizontal', containment:'list1', onUpdate:function(){new Ajax.Request('http://www.example.com/order', {parameters:Sortable.serialize('mylist'), evalScripts:true, asynchronous:true})}})</script>), 
+    assert_equal %(<script type=\"text/javascript\">Sortable.create('mylist', {constraint:'horizontal', containment:'list1', onUpdate:function(){new Ajax.Request('http://www.example.com/order', {asynchronous:true, evalScripts:true, parameters:Sortable.serialize('mylist')})}})</script>), 
       sortable_element("mylist", :containment => 'list1', :constraint => "horizontal", :url => { :action => "order" })
   end
   
@@ -119,13 +123,13 @@ class JavaScriptHelperTest < Test::Unit::TestCase
   end
   
   def test_drop_receiving_element
-    assert_equal %(<script type=\"text/javascript\">Droppables.add('droptarget1', {onDrop:function(element){new Ajax.Request('http://www.example.com/', {parameters:'id=' + encodeURIComponent(element.id), evalScripts:true, asynchronous:true})}})</script>),
+    assert_equal %(<script type=\"text/javascript\">Droppables.add('droptarget1', {onDrop:function(element){new Ajax.Request('http://www.example.com/', {asynchronous:true, evalScripts:true, parameters:'id=' + encodeURIComponent(element.id)})}})</script>),
       drop_receiving_element('droptarget1')
-    assert_equal %(<script type=\"text/javascript\">Droppables.add('droptarget1', {accept:'products', onDrop:function(element){new Ajax.Request('http://www.example.com/', {parameters:'id=' + encodeURIComponent(element.id), evalScripts:true, asynchronous:true})}})</script>),
+    assert_equal %(<script type=\"text/javascript\">Droppables.add('droptarget1', {accept:'products', onDrop:function(element){new Ajax.Request('http://www.example.com/', {asynchronous:true, evalScripts:true, parameters:'id=' + encodeURIComponent(element.id)})}})</script>),
       drop_receiving_element('droptarget1', :accept => 'products')
-    assert_equal %(<script type=\"text/javascript\">Droppables.add('droptarget1', {accept:'products', onDrop:function(element){new Ajax.Updater('infobox', 'http://www.example.com/', {parameters:'id=' + encodeURIComponent(element.id), evalScripts:true, asynchronous:true})}})</script>),
+    assert_equal %(<script type=\"text/javascript\">Droppables.add('droptarget1', {accept:'products', onDrop:function(element){new Ajax.Updater('infobox', 'http://www.example.com/', {asynchronous:true, evalScripts:true, parameters:'id=' + encodeURIComponent(element.id)})}})</script>),
       drop_receiving_element('droptarget1', :accept => 'products', :update => 'infobox')
-    assert_equal %(<script type=\"text/javascript\">Droppables.add('droptarget1', {accept:['tshirts','mugs'], onDrop:function(element){new Ajax.Updater('infobox', 'http://www.example.com/', {parameters:'id=' + encodeURIComponent(element.id), evalScripts:true, asynchronous:true})}})</script>),
+    assert_equal %(<script type=\"text/javascript\">Droppables.add('droptarget1', {accept:['tshirts','mugs'], onDrop:function(element){new Ajax.Updater('infobox', 'http://www.example.com/', {asynchronous:true, evalScripts:true, parameters:'id=' + encodeURIComponent(element.id)})}})</script>),
       drop_receiving_element('droptarget1', :accept => ['tshirts','mugs'], :update => 'infobox')
   end