actionpack 1.9.1 → 1.10.1

data/test/template/form_tag_helper_test.rb

@@ -18,74 +18,80 @@ class FormTagHelperTest < Test::Unit::TestCase
   def test_check_box_tag
     actual = check_box_tag "admin"
     expected = %(<input id="admin" name="admin" type="checkbox" value="1" />)
-    assert_equal expected, actual
+    assert_dom_equal expected, actual
   end
 
   def test_form_tag
     actual = form_tag
     expected = %(<form action="http://www.example.com" method="post">)
-    assert_equal expected, actual
+    assert_dom_equal expected, actual
   end
 
   def test_form_tag_multipart
     actual = form_tag({}, { 'multipart' => true })
     expected = %(<form action="http://www.example.com" enctype="multipart/form-data" method="post">)
-    assert_equal expected, actual
+    assert_dom_equal expected, actual
   end
 
   def test_hidden_field_tag
     actual = hidden_field_tag "id", 3
     expected = %(<input id="id" name="id" type="hidden" value="3" />)
-    assert_equal expected, actual
+    assert_dom_equal expected, actual
   end
 
   def test_password_field_tag
     actual = password_field_tag
     expected = %(<input id="password" name="password" type="password" />)
-    assert_equal expected, actual
+    assert_dom_equal expected, actual
   end
 
   def test_radio_button_tag
     actual = radio_button_tag "people", "david"
     expected = %(<input id="people" name="people" type="radio" value="david" />)
-    assert_equal expected, actual
+    assert_dom_equal expected, actual
   end
 
   def test_select_tag
     actual = select_tag "people", "<option>david</option>"
     expected = %(<select id="people" name="people"><option>david</option></select>)
-    assert_equal expected, actual
+    assert_dom_equal expected, actual
   end
 
   def test_text_area_tag_size_string
     actual = text_area_tag "body", "hello world", "size" => "20x40"
     expected = %(<textarea cols="20" id="body" name="body" rows="40">hello world</textarea>)
-    assert_equal expected, actual
+    assert_dom_equal expected, actual
   end
 
   def test_text_area_tag_size_symbol
     actual = text_area_tag "body", "hello world", :size => "20x40"
     expected = %(<textarea cols="20" id="body" name="body" rows="40">hello world</textarea>)
-    assert_equal expected, actual
+    assert_dom_equal expected, actual
   end
 
   def test_text_field_tag
     actual = text_field_tag "title", "Hello!"
     expected = %(<input id="title" name="title" type="text" value="Hello!" />)
-    assert_equal expected, actual
+    assert_dom_equal expected, actual
   end
 
   def test_text_field_tag_class_string
     actual = text_field_tag "title", "Hello!", "class" => "admin"
     expected = %(<input class="admin" id="title" name="title" type="text" value="Hello!" />)
-    assert_equal expected, actual
+    assert_dom_equal expected, actual
   end
 
   def test_boolean_optios
-    assert_equal %(<input checked="checked" disabled="disabled" id="admin" name="admin" readonly="readonly" type="checkbox" value="1" />), check_box_tag("admin", 1, true, 'disabled' => true, :readonly => "yes")
-    assert_equal %(<input checked="checked" id="admin" name="admin" type="checkbox" value="1" />), check_box_tag("admin", 1, true, :disabled => false, :readonly => nil)
-    assert_equal %(<select id="people" multiple="multiple" name="people"><option>david</option></select>), select_tag("people", "<option>david</option>", :multiple => true)
-    assert_equal %(<select id="people" name="people"><option>david</option></select>), select_tag("people", "<option>david</option>", :multiple => nil)
+    assert_dom_equal %(<input checked="checked" disabled="disabled" id="admin" name="admin" readonly="readonly" type="checkbox" value="1" />), check_box_tag("admin", 1, true, 'disabled' => true, :readonly => "yes")
+    assert_dom_equal %(<input checked="checked" id="admin" name="admin" type="checkbox" value="1" />), check_box_tag("admin", 1, true, :disabled => false, :readonly => nil)
+    assert_dom_equal %(<select id="people" multiple="multiple" name="people"><option>david</option></select>), select_tag("people", "<option>david</option>", :multiple => true)
+    assert_dom_equal %(<select id="people" name="people"><option>david</option></select>), select_tag("people", "<option>david</option>", :multiple => nil)
+  end
+
+  def test_stringify_symbol_keys
+    actual = text_field_tag "title", "Hello!", :id => "admin"
+    expected = %(<input id="admin" name="title" type="text" value="Hello!" />)
+    assert_dom_equal expected, actual
   end
 end
 

data/test/template/java_script_macros_helper_test.rb

@@ -0,0 +1,56 @@
+require File.dirname(__FILE__) + '/../abstract_unit'
+
+class JavaScriptMacrosHelperTest < Test::Unit::TestCase
+  include ActionView::Helpers::JavaScriptHelper
+  include ActionView::Helpers::JavaScriptMacrosHelper
+  
+  include ActionView::Helpers::UrlHelper
+  include ActionView::Helpers::TagHelper
+  include ActionView::Helpers::TextHelper
+  include ActionView::Helpers::FormHelper
+  include ActionView::Helpers::CaptureHelper
+  
+  def setup
+    @controller = Class.new do
+      def url_for(options, *parameters_for_method_reference)
+        url =  "http://www.example.com/"
+        url << options[:action].to_s if options and options[:action]
+        url
+      end
+    end
+    @controller = @controller.new
+  end
+
+
+  def test_auto_complete_field
+    assert_dom_equal %(<script type=\"text/javascript\">\n//<![CDATA[\nnew Ajax.Autocompleter('some_input', 'some_input_auto_complete', 'http://www.example.com/autocomplete', {})\n//]]>\n</script>),
+      auto_complete_field("some_input", :url => { :action => "autocomplete" });
+    assert_dom_equal %(<script type=\"text/javascript\">\n//<![CDATA[\nnew Ajax.Autocompleter('some_input', 'some_input_auto_complete', 'http://www.example.com/autocomplete', {tokens:','})\n//]]>\n</script>),
+      auto_complete_field("some_input", :url => { :action => "autocomplete" }, :tokens => ',');
+    assert_dom_equal %(<script type=\"text/javascript\">\n//<![CDATA[\nnew Ajax.Autocompleter('some_input', 'some_input_auto_complete', 'http://www.example.com/autocomplete', {tokens:[',']})\n//]]>\n</script>),
+      auto_complete_field("some_input", :url => { :action => "autocomplete" }, :tokens => [',']);  
+    assert_dom_equal %(<script type=\"text/javascript\">\n//<![CDATA[\nnew Ajax.Autocompleter('some_input', 'some_input_auto_complete', 'http://www.example.com/autocomplete', {min_chars:3})\n//]]>\n</script>),
+      auto_complete_field("some_input", :url => { :action => "autocomplete" }, :min_chars => 3);
+    assert_dom_equal %(<script type=\"text/javascript\">\n//<![CDATA[\nnew Ajax.Autocompleter('some_input', 'some_input_auto_complete', 'http://www.example.com/autocomplete', {onHide:function(element, update){Alert('me');}})\n//]]>\n</script>),
+      auto_complete_field("some_input", :url => { :action => "autocomplete" }, :on_hide => "function(element, update){Alert('me');}");
+  end
+  
+  def test_auto_complete_result
+    result = [ { :title => 'test1'  }, { :title => 'test2'  } ]
+    assert_equal %(<ul><li>test1</li><li>test2</li></ul>), 
+      auto_complete_result(result, :title)
+    assert_equal %(<ul><li>t<strong class=\"highlight\">est</strong>1</li><li>t<strong class=\"highlight\">est</strong>2</li></ul>), 
+      auto_complete_result(result, :title, "est")
+    
+    resultuniq = [ { :title => 'test1'  }, { :title => 'test1'  } ]
+    assert_equal %(<ul><li>t<strong class=\"highlight\">est</strong>1</li></ul>), 
+      auto_complete_result(resultuniq, :title, "est")
+  end
+  
+  def test_text_field_with_auto_complete
+    assert_match "<style>",
+      text_field_with_auto_complete(:message, :recipient)
+    assert_dom_equal %(<input id=\"message_recipient\" name=\"message[recipient]\" size=\"30\" type=\"text\" /><div class=\"auto_complete\" id=\"message_recipient_auto_complete\"></div><script type=\"text/javascript\">\n//<![CDATA[\nnew Ajax.Autocompleter('message_recipient', 'message_recipient_auto_complete', 'http://www.example.com/auto_complete_for_message_recipient', {})\n//]]>\n</script>),
+      text_field_with_auto_complete(:message, :recipient, {}, :skip_style => true)
+  end
+end

data/test/template/javascript_helper_test.rb

@@ -23,79 +23,102 @@ class JavaScriptHelperTest < Test::Unit::TestCase
   def test_define_javascript_functions
     # check if prototype.js is included first
     assert_not_nil define_javascript_functions.split("\n")[1].match(/Prototype JavaScript framework/)
+    
+    # check that scriptaculous.js is not in here, only needed if loaded remotely
+    assert_nil define_javascript_functions.split("\n")[1].match(/var Scriptaculous = \{/)
   end
 
   def test_escape_javascript
     assert_equal %(This \\"thing\\" is really\\n netos\\'), escape_javascript(%(This "thing" is really\n netos'))
   end
-  
+                                      
   def test_link_to_function
-    assert_equal %(<a href="#" onclick="alert('Hello world!'); return false;">Greeting</a>), 
+    assert_dom_equal %(<a href="#" onclick="alert('Hello world!'); return false;">Greeting</a>), 
       link_to_function("Greeting", "alert('Hello world!')")
   end
   
   def test_link_to_remote
-    assert_equal %(<a class=\"fine\" href=\"#\" onclick=\"new Ajax.Request('http://www.example.com/whatnot', {asynchronous:true, evalScripts:true}); return false;\">Remote outpost</a>),
+    assert_dom_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', {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"  })
+    assert_dom_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"  })      
+    assert_dom_equal %(<a href=\"#\" onclick=\"new Ajax.Request('http://www.example.com/whatnot', {asynchronous:true, evalScripts:true, onSuccess:function(request){alert(request.reponseText)}}); return false;\">Remote outpost</a>),
+      link_to_remote("Remote outpost", :success => "alert(request.reponseText)", :url => { :action => "whatnot"  })
+    assert_dom_equal %(<a href=\"#\" onclick=\"new Ajax.Request('http://www.example.com/whatnot', {asynchronous:true, evalScripts:true, onFailure:function(request){alert(request.reponseText)}}); return false;\">Remote outpost</a>),
+      link_to_remote("Remote outpost", :failure => "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', {asynchronous:true, evalScripts:true})}, 10)</script>),
+    assert_dom_equal %(<script type="text/javascript">\n//<![CDATA[\nnew PeriodicalExecuter(function() {new Ajax.Updater('schremser_bier', 'http://www.example.com/mehr_bier', {asynchronous:true, evalScripts:true})}, 10)\n//]]>\n</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', {asynchronous:true, evalScripts:true, parameters:Form.serialize(this)}); return false;\">),
+    assert_dom_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', {asynchronous:true, evalScripts:true, parameters:Form.serialize(this)}); return false;\">),
+    assert_dom_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', {asynchronous:true, evalScripts:true, parameters:Form.serialize(this)}); return false;\">),
+    assert_dom_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', {asynchronous:true, evalScripts:true, parameters:Form.serialize(this)}); return false;\">),
+    assert_dom_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_on_callbacks
+    callbacks = [:uninitialized, :loading, :loaded, :interactive, :complete, :success, :failure]
+    callbacks.each do |callback|
+      assert_dom_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, on#{callback.to_s.capitalize}:function(request){monkeys();}, parameters:Form.serialize(this)}); return false;">),
+        form_remote_tag(:update => "glass_of_beer", :url => { :action => :fast  }, callback=>"monkeys();")
+      assert_dom_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, on#{callback.to_s.capitalize}:function(request){monkeys();}, parameters:Form.serialize(this)}); return false;">),
+        form_remote_tag(:update => { :success => "glass_of_beer" }, :url => { :action => :fast  }, callback=>"monkeys();")
+      assert_dom_equal %(<form action=\"http://www.example.com/fast\" method=\"post\" onsubmit=\"new Ajax.Updater({failure:'glass_of_beer'}, 'http://www.example.com/fast', {asynchronous:true, evalScripts:true, on#{callback.to_s.capitalize}:function(request){monkeys();}, parameters:Form.serialize(this)}); return false;">),
+        form_remote_tag(:update => { :failure => "glass_of_beer" }, :url => { :action => :fast  }, callback=>"monkeys();")
+      assert_dom_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, on#{callback.to_s.capitalize}:function(request){monkeys();}, parameters:Form.serialize(this)}); return false;">),
+        form_remote_tag(:update => { :success => "glass_of_beer", :failure => "glass_of_water" }, :url => { :action => :fast  }, callback=>"monkeys();")
+    end
+    
+    #HTTP status codes 200 up to 599 have callbacks
+    #these should work
+    100.upto(599) do |callback|
+      assert_dom_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, on#{callback.to_s.capitalize}:function(request){monkeys();}, parameters:Form.serialize(this)}); return false;">),
+        form_remote_tag(:update => "glass_of_beer", :url => { :action => :fast  }, callback=>"monkeys();")
+    end
+    
+    #test 200 and 404
+    assert_dom_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, on200:function(request){monkeys();}, on404:function(request){bananas();}, parameters:Form.serialize(this)}); return false;">),
+      form_remote_tag(:update => "glass_of_beer", :url => { :action => :fast  }, 200=>"monkeys();", 404=>"bananas();")
+    
+    #these shouldn't
+    1.upto(99) do |callback|
+      assert_dom_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  }, callback=>"monkeys();")
+    end
+    600.upto(999) do |callback|
+      assert_dom_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  }, callback=>"monkeys();")
+    end
+    
+    #test ultimate combo
+    assert_dom_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, on200:function(request){monkeys();}, on404:function(request){bananas();}, onComplete:function(request){c();}, onFailure:function(request){f();}, onLoading:function(request){c1()}, onSuccess:function(request){s()}, parameters:Form.serialize(this)}); return false;\">),
+      form_remote_tag(:update => "glass_of_beer", :url => { :action => :fast  }, :loading => "c1()", :success => "s()", :failure => "f();", :complete => "c();", 200=>"monkeys();", 404=>"bananas();")
+    
+  end
+  
   def test_submit_to_remote
-    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\" />),
+    assert_dom_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', {asynchronous:true, evalScripts:true})})</script>),
+    assert_dom_equal %(<script type=\"text/javascript\">\n//<![CDATA[\nnew Form.Element.Observer('glass', 300, function(element, value) {new Ajax.Request('http://www.example.com/reorder_if_empty', {asynchronous:true, evalScripts:true})})\n//]]>\n</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', {asynchronous:true, evalScripts:true})})</script>),
+    assert_dom_equal %(<script type=\"text/javascript\">\n//<![CDATA[\nnew Form.Observer('cart', 2, function(element, value) {new Ajax.Request('http://www.example.com/cart_changed', {asynchronous:true, evalScripts:true})})\n//]]>\n</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" });
-    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
-    result = [ { :title => 'test1'  }, { :title => 'test2'  } ]
-    assert_equal %(<ul><li>test1</li><li>test2</li></ul>), 
-      auto_complete_result(result, :title)
-    assert_equal %(<ul><li>t<strong class=\"highlight\">est</strong>1</li><li>t<strong class=\"highlight\">est</strong>2</li></ul>), 
-      auto_complete_result(result, :title, "est")
-  end
-  
-  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\" /><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
-  
   def test_effect
     assert_equal "new Effect.Highlight('posts',{});", visual_effect(:highlight, "posts")
     assert_equal "new Effect.Highlight('posts',{});", visual_effect("highlight", :posts)
@@ -105,31 +128,31 @@ 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', {asynchronous:true, evalScripts:true, parameters:Sortable.serialize('mylist')})}})</script>), 
+    assert_dom_equal %(<script type=\"text/javascript\">\n//<![CDATA[\nSortable.create('mylist', {onUpdate:function(){new Ajax.Request('http://www.example.com/order', {asynchronous:true, evalScripts:true, parameters:Sortable.serialize('mylist')})}})\n//]]>\n</script>), 
       sortable_element("mylist", :url => { :action => "order" })
-    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>), 
+    assert_equal %(<script type=\"text/javascript\">\n//<![CDATA[\nSortable.create('mylist', {constraint:'horizontal', onUpdate:function(){new Ajax.Request('http://www.example.com/order', {asynchronous:true, evalScripts:true, parameters:Sortable.serialize('mylist')})}, tag:'div'})\n//]]>\n</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', {asynchronous:true, evalScripts:true, parameters:Sortable.serialize('mylist')})}})</script>|, 
+    assert_dom_equal %|<script type=\"text/javascript\">\n//<![CDATA[\nSortable.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')})}})\n//]]>\n</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', {asynchronous:true, evalScripts:true, parameters:Sortable.serialize('mylist')})}})</script>), 
+    assert_dom_equal %(<script type=\"text/javascript\">\n//<![CDATA[\nSortable.create('mylist', {constraint:'horizontal', containment:'list1', onUpdate:function(){new Ajax.Request('http://www.example.com/order', {asynchronous:true, evalScripts:true, parameters:Sortable.serialize('mylist')})}})\n//]]>\n</script>), 
       sortable_element("mylist", :containment => 'list1', :constraint => "horizontal", :url => { :action => "order" })
   end
   
   def test_draggable_element
-    assert_equal %(<script type=\"text/javascript\">new Draggable('product_13', {})</script>),
+    assert_dom_equal %(<script type=\"text/javascript\">\n//<![CDATA[\nnew Draggable('product_13', {})\n//]]>\n</script>),
       draggable_element('product_13')
-    assert_equal %(<script type=\"text/javascript\">new Draggable('product_13', {revert:true})</script>),
+    assert_equal %(<script type=\"text/javascript\">\n//<![CDATA[\nnew Draggable('product_13', {revert:true})\n//]]>\n</script>),
       draggable_element('product_13', :revert => true)
   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/', {asynchronous:true, evalScripts:true, parameters:'id=' + encodeURIComponent(element.id)})}})</script>),
+    assert_dom_equal %(<script type=\"text/javascript\">\n//<![CDATA[\nDroppables.add('droptarget1', {onDrop:function(element){new Ajax.Request('http://www.example.com/', {asynchronous:true, evalScripts:true, parameters:'id=' + encodeURIComponent(element.id)})}})\n//]]>\n</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/', {asynchronous:true, evalScripts:true, parameters:'id=' + encodeURIComponent(element.id)})}})</script>),
+    assert_dom_equal %(<script type=\"text/javascript\">\n//<![CDATA[\nDroppables.add('droptarget1', {accept:'products', onDrop:function(element){new Ajax.Request('http://www.example.com/', {asynchronous:true, evalScripts:true, parameters:'id=' + encodeURIComponent(element.id)})}})\n//]]>\n</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/', {asynchronous:true, evalScripts:true, parameters:'id=' + encodeURIComponent(element.id)})}})</script>),
+    assert_dom_equal %(<script type=\"text/javascript\">\n//<![CDATA[\nDroppables.add('droptarget1', {accept:'products', onDrop:function(element){new Ajax.Updater('infobox', 'http://www.example.com/', {asynchronous:true, evalScripts:true, parameters:'id=' + encodeURIComponent(element.id)})}})\n//]]>\n</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/', {asynchronous:true, evalScripts:true, parameters:'id=' + encodeURIComponent(element.id)})}})</script>),
+    assert_dom_equal %(<script type=\"text/javascript\">\n//<![CDATA[\nDroppables.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)})}})\n//]]>\n</script>),
       drop_receiving_element('droptarget1', :accept => ['tshirts','mugs'], :update => 'infobox')
   end
   

data/test/template/number_helper_test.rb

@@ -18,6 +18,8 @@ class NumberHelperTest < Test::Unit::TestCase
   def test_number_to_currency
     assert_equal("$1,234,567,890.50", number_to_currency(1234567890.50))
     assert_equal("$1,234,567,890.51", number_to_currency(1234567890.506))
+    assert_equal("$1,234,567,890", number_to_currency(1234567890.50, {:precision => 0}))
+    assert_equal("$1,234,567,890.5", number_to_currency(1234567890.50, {:precision => 1}))
     assert_equal("&pound;1234567890,50", number_to_currency(1234567890.50, {:unit => "&pound;", :separator => ",", :delimiter => ""}))
   end
 

data/test/template/tag_helper_test.rb

@@ -24,9 +24,18 @@ class TagHelperTest < Test::Unit::TestCase
     assert_equal "<p included=\"\" />", tag("p", :included => '')
   end
 
+  def test_tag_options_converts_boolean_option
+    assert_equal '<p disabled="disabled" multiple="multiple" readonly="readonly" />',
+      tag("p", :disabled => true, :multiple => true, :readonly => true)
+  end
+
   def test_content_tag
     assert_equal "<a href=\"create\">Create</a>", content_tag("a", "Create", "href" => "create")
     assert_equal content_tag("a", "Create", "href" => "create"),
                  content_tag("a", "Create", :href => "create")
   end
+  
+  def test_cdata_section
+    assert_equal "<![CDATA[<hello world>]]>", cdata_section("<hello world>")
+  end
 end

data/test/template/text_helper_test.rb

@@ -1,10 +1,20 @@
 require 'test/unit'
+require "#{File.dirname(__FILE__)}/../testing_sandbox"
 require File.dirname(__FILE__) + '/../../lib/action_view/helpers/text_helper'
 require File.dirname(__FILE__) + '/../../../activesupport/lib/active_support/core_ext/numeric'  # for human_size
+require File.dirname(__FILE__) + '/../../../activesupport/lib/active_support/core_ext/hash' # for stringify_keys
+require File.dirname(__FILE__) + '/../../../activesupport/lib/active_support/core_ext/object_and_class.rb' # for blank?
 
 class TextHelperTest < Test::Unit::TestCase
   include ActionView::Helpers::TextHelper
   include ActionView::Helpers::TagHelper
+  include TestingSandbox
+  
+  def setup
+    # This simulates the fact that instance variables are reset every time
+    # a view is rendered.  The cycle helper depends on this behavior.
+    @_cycles = nil if (defined? @_cycles)
+  end
   
   def test_simple_format
     assert_equal "<p>crazy\n<br /> cross\n<br /> platform linebreaks</p>", simple_format("crazy\r\n cross\r platform linebreaks")
@@ -17,6 +27,29 @@ class TextHelperTest < Test::Unit::TestCase
     assert_equal "Hello Worl...", truncate("Hello World!!", 12)
   end
 
+  def test_truncate_multibyte_without_kcode
+    result = execute_in_sandbox(<<-'CODE')
+      require "#{File.dirname(__FILE__)}/../lib/action_view/helpers/text_helper"
+      include ActionView::Helpers::TextHelper
+      truncate("\354\225\210\353\205\225\355\225\230\354\204\270\354\232\224", 10)
+    CODE
+
+    assert_equal "\354\225\210\353\205\225\355\225...", result
+  end
+
+  def test_truncate_multibyte_with_kcode
+    result = execute_in_sandbox(<<-'CODE')
+      $KCODE = "u"
+      require 'jcode'
+
+      require "#{File.dirname(__FILE__)}/../lib/action_view/helpers/text_helper"
+      include ActionView::Helpers::TextHelper
+      truncate("\354\225\204\353\246\254\353\236\221 \354\225\204\353\246\254\353\236 \354\225\204\353\235\274\353\246\254\354\230\244", 10)
+    CODE
+
+    assert_equal "\354\225\204\353\246\254\353\236\221 \354\225\204\353\246\254\353\236 \354\225\204...", result
+  end
+
   def test_strip_links
     assert_equal "on my mind", strip_links("<a href='almost'>on my mind</a>")
   end
@@ -67,7 +100,13 @@ class TextHelperTest < Test::Unit::TestCase
     assert_equal("...iful morning", excerpt("This is a beautiful morning", "morning", 5))
     assert_nil excerpt("This is a beautiful morning", "day")
   end
+
+  def test_excerpt_with_regex
+    assert_equal('...is a beautiful! morn...', excerpt('This is a beautiful! morning', 'beautiful', 5))
+    assert_equal('...is a beautiful? morn...', excerpt('This is a beautiful? morning', 'beautiful', 5))
+  end
   
+    
   def test_word_wrap
     assert_equal("my very very\nvery long\nstring", word_wrap("my very very very long string", 15))
   end
@@ -85,6 +124,10 @@ class TextHelperTest < Test::Unit::TestCase
     link_result_with_options  = %{<a href="#{link_raw}" target="_blank">#{link_raw}</a>}
     link2_raw    = 'www.rubyonrails.com'
     link2_result = %{<a href="http://#{link2_raw}">#{link2_raw}</a>}
+    link3_raw    = 'http://manuals.ruby-on-rails.com/read/chapter.need_a-period/103#page281'
+    link3_result = %{<a href="#{link3_raw}">#{link3_raw}</a>}
+    link4_raw    = 'http://foo.example.com/controller/action?parm=value&p2=v2#anchor123'
+    link4_result = %{<a href="#{link4_raw}">#{link4_raw}</a>}
 
     assert_equal %(hello #{email_result}), auto_link("hello #{email_raw}", :email_addresses)
     assert_equal %(Go to #{link_result}), auto_link("Go to #{link_raw}", :urls)
@@ -92,11 +135,30 @@ class TextHelperTest < Test::Unit::TestCase
     assert_equal %(Go to #{link_result} and say hello to #{email_result}), auto_link("Go to #{link_raw} and say hello to #{email_raw}")
     assert_equal %(<p>Link #{link_result}</p>), auto_link("<p>Link #{link_raw}</p>")
     assert_equal %(<p>#{link_result} Link</p>), auto_link("<p>#{link_raw} Link</p>")
+    assert_equal %(<p>Link #{link_result_with_options}</p>), auto_link("<p>Link #{link_raw}</p>", :all, {:target => "_blank"})
+    assert_equal %(Go to #{link_result}.), auto_link(%(Go to #{link_raw}.))
+    assert_equal %(<p>Go to #{link_result}, then say hello to #{email_result}.</p>), auto_link(%(<p>Go to #{link_raw}, then say hello to #{email_raw}.</p>))
     assert_equal %(Go to #{link2_result}), auto_link("Go to #{link2_raw}", :urls)
     assert_equal %(Go to #{link2_raw}), auto_link("Go to #{link2_raw}", :email_addresses)
     assert_equal %(<p>Link #{link2_result}</p>), auto_link("<p>Link #{link2_raw}</p>")
     assert_equal %(<p>#{link2_result} Link</p>), auto_link("<p>#{link2_raw} Link</p>")
-    assert_equal %(<p>Link #{link_result_with_options}</p>), auto_link("<p>Link #{link_raw}</p>", :all, {:target => "_blank"})
+    assert_equal %(Go to #{link2_result}.), auto_link(%(Go to #{link2_raw}.))
+    assert_equal %(<p>Say hello to #{email_result}, then go to #{link2_result}.</p>), auto_link(%(<p>Say hello to #{email_raw}, then go to #{link2_raw}.</p>))
+    assert_equal %(Go to #{link3_result}), auto_link("Go to #{link3_raw}", :urls)
+    assert_equal %(Go to #{link3_raw}), auto_link("Go to #{link3_raw}", :email_addresses)
+    assert_equal %(<p>Link #{link3_result}</p>), auto_link("<p>Link #{link3_raw}</p>")
+    assert_equal %(<p>#{link3_result} Link</p>), auto_link("<p>#{link3_raw} Link</p>")
+    assert_equal %(Go to #{link3_result}.), auto_link(%(Go to #{link3_raw}.))
+    assert_equal %(<p>Go to #{link3_result}. seriously, #{link3_result}? i think I'll say hello to #{email_result}. instead.</p>), auto_link(%(<p>Go to #{link3_raw}. seriously, #{link3_raw}? i think I'll say hello to #{email_raw}. instead.</p>))
+    assert_equal %(<p>Link #{link4_result}</p>), auto_link("<p>Link #{link4_raw}</p>")
+    assert_equal %(<p>#{link4_result} Link</p>), auto_link("<p>#{link4_raw} Link</p>")
+  end
+
+  def test_auto_link_at_eol
+    url1 = "http://api.rubyonrails.com/Foo.html"
+    url2 = "http://www.ruby-doc.org/core/Bar.html"
+
+    assert_equal %(<p><a href="#{url1}">#{url1}</a><br /><a href="#{url2}">#{url2}</a><br /></p>), auto_link("<p>#{url1}<br />#{url2}<br /></p>")
   end
 
   def test_sanitize_form
@@ -123,4 +185,87 @@ class TextHelperTest < Test::Unit::TestCase
     assert_equal %{href="javascript:bang" <a name='hello'>foo</a>, <span>bar</span>}, result
   end
   
+  def test_cycle_class
+    value = Cycle.new("one", 2, "3")
+    assert_equal("one", value.to_s)
+    assert_equal("2", value.to_s)
+    assert_equal("3", value.to_s)
+    assert_equal("one", value.to_s)
+    value.reset
+    assert_equal("one", value.to_s)
+    assert_equal("2", value.to_s)
+    assert_equal("3", value.to_s)
+  end
+  
+  def test_cycle_class_with_no_arguments
+    assert_raise(ArgumentError) { value = Cycle.new() }
+  end
+
+  def test_cycle
+    assert_equal("one", cycle("one", 2, "3"))
+    assert_equal("2", cycle("one", 2, "3"))
+    assert_equal("3", cycle("one", 2, "3"))
+    assert_equal("one", cycle("one", 2, "3"))
+    assert_equal("2", cycle("one", 2, "3"))
+    assert_equal("3", cycle("one", 2, "3"))
+  end
+  
+  def test_cycle_with_no_arguments
+    assert_raise(ArgumentError) { value = cycle() }
+  end
+  
+  def test_cycle_resets_with_new_values
+    assert_equal("even", cycle("even", "odd"))
+    assert_equal("odd", cycle("even", "odd"))
+    assert_equal("even", cycle("even", "odd"))
+    assert_equal("1", cycle(1, 2, 3))
+    assert_equal("2", cycle(1, 2, 3))
+    assert_equal("3", cycle(1, 2, 3))
+    assert_equal("1", cycle(1, 2, 3))
+  end
+  
+  def test_named_cycles
+    assert_equal("1", cycle(1, 2, 3, :name => "numbers"))
+    assert_equal("red", cycle("red", "blue", :name => "colors"))
+    assert_equal("2", cycle(1, 2, 3, :name => "numbers"))
+    assert_equal("blue", cycle("red", "blue", :name => "colors"))
+    assert_equal("3", cycle(1, 2, 3, :name => "numbers"))
+    assert_equal("red", cycle("red", "blue", :name => "colors"))
+  end
+  
+  def test_default_named_cycle
+    assert_equal("1", cycle(1, 2, 3))
+    assert_equal("2", cycle(1, 2, 3, :name => "default"))
+    assert_equal("3", cycle(1, 2, 3))
+  end
+  
+  def test_reset_cycle
+    assert_equal("1", cycle(1, 2, 3))
+    assert_equal("2", cycle(1, 2, 3))
+    reset_cycle
+    assert_equal("1", cycle(1, 2, 3))
+  end
+  
+  def test_reset_unknown_cycle
+    reset_cycle("colors")
+  end
+  
+  def test_recet_named_cycle
+    assert_equal("1", cycle(1, 2, 3, :name => "numbers"))
+    assert_equal("red", cycle("red", "blue", :name => "colors"))
+    reset_cycle("numbers")
+    assert_equal("1", cycle(1, 2, 3, :name => "numbers"))
+    assert_equal("blue", cycle("red", "blue", :name => "colors"))
+    assert_equal("2", cycle(1, 2, 3, :name => "numbers"))
+    assert_equal("red", cycle("red", "blue", :name => "colors"))
+  end
+  
+  def test_cycle_no_instance_variable_clashes
+    @cycles = %w{Specialized Fuji Giant}
+    assert_equal("red", cycle("red", "blue"))
+    assert_equal("blue", cycle("red", "blue"))
+    assert_equal("red", cycle("red", "blue"))
+    assert_equal(%w{Specialized Fuji Giant}, @cycles)
+  end
+
 end