RubyGems - erector - Versions diffs - 0.3.110 → 0.4.191 - Mend

erector 0.3.110 → 0.4.191

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (38) hide show

data/README.txt +1 -1
data/bin/erect +0 -0
data/lib/erector.rb +13 -10
data/lib/erector/doc.rb +138 -0
data/lib/erector/erected.rb +1 -1
data/lib/erector/rails.rb +6 -0
data/lib/erector/rails/extensions/action_controller.rb +17 -0
data/lib/erector/rails/extensions/action_view.rb +21 -0
data/lib/erector/{helpers.rb → rails/extensions/widget.rb} +21 -14
data/lib/erector/rails/supported_rails_versions.rb +11 -0
data/lib/erector/rails/template_handlers/action_view_template_handler.rb +92 -0
data/lib/erector/rhtml.treetop +6 -1
data/lib/erector/unicode.rb +18185 -0
data/lib/erector/unicode_builder.rb +67 -0
data/lib/erector/widget.rb +86 -82
data/spec/core_spec_suite.rb +3 -0
data/spec/erect/erect_spec.rb +1 -4
data/spec/erect/erected_spec.rb +1 -4
data/spec/erect/rhtml_parser_spec.rb +9 -7
data/spec/erector/doc_spec.rb +55 -0
data/spec/erector/indentation_spec.rb +127 -0
data/spec/erector/unicode_builder_spec.rb +75 -0
data/spec/erector/widget_spec.rb +339 -175
data/spec/erector/widgets/table_spec.rb +26 -37
data/spec/rails_spec_suite.rb +3 -0
data/spec/spec_helper.rb +11 -6
data/spec/spec_suite.rb +44 -3
metadata +54 -28
data/lib/erector/extensions/action_controller.rb +0 -24
data/lib/erector/extensions/action_view_template_handler.rb +0 -66
data/lib/erector/html_parts.rb +0 -63
data/spec/erector/extensions/render_widget_spec.rb +0 -68
data/spec/erector/extensions/template_handler_spec.rb +0 -29
data/spec/erector/rails_helpers_spec.rb +0 -149
data/spec/rails/standard_helpers_spec.rb +0 -102
data/spec/rails/view_spec.rb +0 -33
data/spec/view_caching.rb +0 -30
data/test/rails_root/app/views/template_handler_spec/test_page.rb +0 -8

data/spec/erector/indentation_spec.rb ADDED

@@ -0,0 +1,127 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../spec_helper")
+describe "indentation" do
+  it "can detect newliney tags" do
+    doc = Erector::Doc.new(StringIO.new(""))
+    doc.enable_prettyprint = true
+    doc.newliney("i").should == false
+    doc.newliney("table").should == true
+  end
+  it "should not add newline for non-newliney tags" do
+    Erector::Widget.new() do
+      text "Hello, "
+      b "World"
+    end.enable_prettyprint(true).to_s.should == "Hello, <b>World</b>"
+  end
+  it "should add newlines before open newliney tags" do
+    Erector::Widget.new() do
+      p "foo"
+      p "bar"
+    end.enable_prettyprint(true).to_s.should == "<p>foo</p>\n<p>bar</p>\n"
+  end
+  it "should add newlines between text and open newliney tag" do
+    Erector::Widget.new() do
+      text "One"
+      p "Two"
+    end.enable_prettyprint(true).to_s.should == "One\n<p>Two</p>\n"
+  end
+  it "should add newlines after end newliney tags" do
+    Erector::Widget.new() do
+      tr do
+        td "cell"
+      end
+    end.enable_prettyprint(true).to_s.should == "<tr>\n  <td>cell</td>\n</tr>\n"
+  end
+  it "should treat empty elements as start and end" do
+    Erector::Widget.new() do
+      p "before"
+      br
+      p "after"
+    end.enable_prettyprint(true).to_s.should == "<p>before</p>\n<br />\n<p>after</p>\n"
+  end
+  it "empty elements sets at_start_of_line" do
+    Erector::Widget.new() do
+      text "before"
+      br
+      p "after"
+    end.enable_prettyprint(true).to_s.should == "before\n<br />\n<p>after</p>\n"
+  end
+  it "will not insert extra space before/after input element" do
+    # If dim memory serves, the reason for not adding spaces here is
+    # because it affects/affected the rendering in browsers.
+    Erector::Widget.new() do
+      text 'Name'
+      input :type => 'text'
+      text 'after'
+    end.enable_prettyprint(true).to_s.should == 'Name<input type="text" />after'
+  end
+  it "will indent" do
+    Erector::Widget.new() do
+      html do
+        head do
+          title "hi"
+        end
+        body do
+          div do
+            p "paragraph"
+          end
+        end
+      end
+    end.enable_prettyprint(true).to_s.should == <<END
+<html>
+  <head>
+    <title>hi</title>
+  </head>
+  <body>
+    <div>
+      <p>paragraph</p>
+    </div>
+  </body>
+</html>
+END
+  end
+  it "can turn off newlines" do
+    Erector::Widget.new() do
+      text "One"
+      p "Two"
+    end.enable_prettyprint(false).to_s.should == "One<p>Two</p>"
+  end
+  it "cannot turn newlines on and off, because the output is cached" do
+    widget = Erector::Widget.new() do
+      text "One"
+      p "Two"
+    end.enable_prettyprint(false)
+    widget.to_s.should == "One<p>Two</p>"
+    widget.enable_prettyprint(true)
+    widget.to_s.should == "One<p>Two</p>"
+    widget.enable_prettyprint(false)
+    widget.to_s.should == "One<p>Two</p>"
+  end
+  it "can turn on newlines via to_pretty" do
+    widget = Erector::Widget.new() do
+      text "One"
+      p "Two"
+    end.enable_prettyprint(false).to_pretty.should == "One\n<p>Two</p>\n"
+  end
+  it "to_pretty will leave newlines on if they already were" do
+    widget = Erector::Widget.new() do
+      text "One"
+      p "Two"
+    end.enable_prettyprint(true).to_pretty.should == "One\n<p>Two</p>\n"
+  end
+end

data/spec/erector/unicode_builder_spec.rb ADDED

@@ -0,0 +1,75 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../spec_helper")
+require File.expand_path("#{File.dirname(__FILE__)}/../../lib/erector/unicode_builder")
+describe "build unicode" do
+  def make_builder(input_string)
+    @output = ""
+    Erector::UnicodeBuilder.new(
+      StringIO.new(input_string),
+      StringIO.new(@output))
+  end
+  it "#generate generates header and footer" do
+    make_builder("").generate()
+    @output.should == "Erector::CHARACTERS = {\n}\n"
+  end
+  it "generates nothing from empty file" do
+    make_builder("").process_file()
+    @output.should == ""
+  end
+  it "generates nothing from blank line" do
+    make_builder("\n").process_file()
+    @output.should == ""
+  end
+  it "generates entry from a simple line" do
+    make_builder(%q{
+0025;PERCENT SIGN;Po;0;ET;;;;;N;;;;;
+    }).process_file()
+    @output.should == "  :percent_sign => 0x0025\n"
+  end
+  it "can process two lines" do
+    make_builder(%q{
+0906;DEVANAGARI LETTER AA;Lo;0;L;;;;;N;;;;;
+237E;BELL SYMBOL;So;0;ON;;;;;N;;;;;
+    }).process_file()
+    @output.should == "  :devanagari_letter_aa => 0x0906,\n" +
+      "  :bell_symbol => 0x237e\n"
+  end
+  it "also adds an entry for an alias" do
+    make_builder(%q{
+2192;RIGHTWARDS ARROW;Sm;0;ON;;;;;N;RIGHT ARROW;;;;
+    }).process_file()
+    @output.should == "  :rightwards_arrow => 0x2192,\n" +
+      "  :right_arrow => 0x2192\n"
+  end
+  it "can handle hyphen in name" do
+    make_builder(%q{
+2673;RECYCLING SYMBOL FOR TYPE-1 PLASTICS;So;0;ON;;;;;N;;pete;;;
+    }).process_file()
+    @output.should == "  :recycling_symbol_for_type_1_plastics => 0x2673\n"
+  end
+  it "can handle characters above 0xffff" do
+    make_builder(%q{
+10400;DESERET CAPITAL LETTER LONG I;Lu;0;L;;;;;N;;;;10428;
+    }).process_file()
+    @output.should == "  :deseret_capital_letter_long_i => 0x10400\n"
+  end
+  it "ignores entries whose names start with less than" do
+    make_builder(%q{
+F0000;<Plane 15 Private Use, First>;Co;0;L;;;;;N;;;;;
+FFFFD;<Plane 15 Private Use, Last>;Co;0;L;;;;;N;;;;;
+    }).process_file()
+    @output.should == ""
+  end
+end

data/spec/erector/widget_spec.rb CHANGED

@@ -9,6 +9,48 @@ module WidgetSpec
       end
     end
+    describe "#to_s" do
+      class << self
+        define_method("invokes #render and returns the string representation of the rendered widget") do
+          it "invokes #render and returns the string representation of the rendered widget" do
+            widget = Erector::Widget.new do
+              div "Hello"
+            end
+            mock.proxy(widget).render
+            widget.to_s.should == "<div>Hello</div>"
+          end
+        end
+      end
+      context "when passed no arguments" do
+        send "invokes #render and returns the string representation of the rendered widget"
+      end
+      context "when passed an argument that is #render" do
+        send "invokes #render and returns the string representation of the rendered widget"
+      end
+      context "when passed an argument that is not #render" do
+        attr_reader :widget
+        before do
+          @widget = Erector::Widget.new
+          def widget.alternate_render
+            div "Hello from Alternate Render"
+          end
+          mock.proxy(widget).alternate_render
+        end
+        it "invokes the passed in method name and returns the string representation of the rendered widget" do
+          widget.to_s(:alternate_render).should == "<div>Hello from Alternate Render</div>"
+        end
+        it "does not invoke #render" do
+          dont_allow(widget).render
+          widget.to_s(:alternate_render)
+        end
+      end
+    end
     describe "#instruct" do
       it "when passed no arguments; returns an XML declaration with version 1 and utf-8" do
         html = Erector::Widget.new do
@@ -18,97 +60,157 @@ module WidgetSpec
       end
     end
+    describe "#widget" do
+      context "when nested" do
+        it "renders the tag around the rest of the block" do
+          parent_widget = Class.new(Erector::Widget) do
+            def render
+              div :id => "parent_widget" do
+                super
+              end
+            end
+          end
+          child_widget = Class.new(Erector::Widget) do
+            def render
+              div :id => "child_widget" do
+                super
+              end
+            end
+          end
+          widget = Class.new(Erector::Widget) do
+            def render
+              widget(parent_widget) do
+                widget(child_widget) do
+                  super
+                end
+              end
+            end
+          end
+          widget.new(nil, :parent_widget => parent_widget, :child_widget => child_widget) do
+            div :id => "widget"
+          end.to_s.should == '<div id="parent_widget"><div id="child_widget"><div id="widget"></div></div></div>'
+        end
+      end
+    end
     describe "#element" do
-      it "when receiving one argument; returns an empty element" do
-        Erector::Widget.new do
-          element('div')
-        end.to_s.should == "<div></div>"
+      context "when receiving one argument" do
+        it "returns an empty element" do
+          Erector::Widget.new do
+            element('div')
+          end.to_s.should == "<div></div>"
+        end
       end
-      it "with a attribute hash; returns an empty element with the attributes" do
-        html = Erector::Widget.new do
-          element(
-            'div',
+      context "with a attribute hash" do
+        it "returns an empty element with the attributes" do
+          html = Erector::Widget.new do
+            element(
+              'div',
               :class => "foo bar",
               :style => "display: none; color: white; float: left;",
               :nil_attribute => nil
-          )
-        end.to_s
-        doc = Hpricot(html)
-        div = doc.at('div')
-        div[:class].should == "foo bar"
-        div[:style].should == "display: none; color: white; float: left;"
-        div[:nil_attribute].should be_nil
+            )
+          end.to_s
+          doc = Hpricot(html)
+          div = doc.at('div')
+          div[:class].should == "foo bar"
+          div[:style].should == "display: none; color: white; float: left;"
+          div[:nil_attribute].should be_nil
+        end
       end
-      it "with an array of CSS classes, returns a tag with the classes separated" do
-        Erector::Widget.new do
-          element('div', :class => [:foo, :bar])
-        end.to_s.should == "<div class=\"foo bar\"></div>";
+      context "with an array of CSS classes" do
+        it "returns a tag with the classes separated" do
+          Erector::Widget.new do
+            element('div', :class => [:foo, :bar])
+          end.to_s.should == "<div class=\"foo bar\"></div>";
+        end
       end
-      it "with an array of CSS classes as strings, returns a tag with the classes separated" do
-        Erector::Widget.new do
-          element('div', :class => ['foo', 'bar'])
-        end.to_s.should == "<div class=\"foo bar\"></div>";
+      context "with an array of CSS classes as strings" do
+        it "returns a tag with the classes separated" do
+          Erector::Widget.new do
+            element('div', :class => ['foo', 'bar'])
+          end.to_s.should == "<div class=\"foo bar\"></div>";
+        end
       end
-      it "with a CSS class which is a string, just use that as the attribute value" do
-        Erector::Widget.new do
-          element('div', :class => "foo bar")
-        end.to_s.should == "<div class=\"foo bar\"></div>";
+      context "with a CSS class which is a string" do
+        it "just use that as the attribute value" do
+          Erector::Widget.new do
+            element('div', :class => "foo bar")
+          end.to_s.should == "<div class=\"foo bar\"></div>";
+        end
       end
-      it "with many attributes, alphabetize them" do
-        Erector::Widget.new do
-          empty_element('foo', :alpha => "", :betty => "5", :aardvark => "tough",
-            :carol => "", :demon => "", :erector => "", :pi => "3.14", :omicron => "", :zebra => "", :brain => "")
-        end.to_s.should == "<foo aardvark=\"tough\" alpha=\"\" betty=\"5\" brain=\"\" carol=\"\" demon=\"\" " \
-           "erector=\"\" omicron=\"\" pi=\"3.14\" zebra=\"\" />";
+      context "with many attributes" do
+        it "alphabetize them" do
+            Erector::Widget.new do
+              empty_element('foo', :alpha => "", :betty => "5", :aardvark => "tough",
+                :carol => "", :demon => "", :erector => "", :pi => "3.14", :omicron => "", :zebra => "", :brain => "")
+            end.to_s.should == "<foo aardvark=\"tough\" alpha=\"\" betty=\"5\" brain=\"\" carol=\"\" demon=\"\" " \
+               "erector=\"\" omicron=\"\" pi=\"3.14\" zebra=\"\" />";
+          end
       end
-      it "with inner tags; returns nested tags" do
-        widget = Erector::Widget.new do
-          element 'div' do
-            element 'div'
+      context "with inner tags" do
+        it "returns nested tags" do
+          widget = Erector::Widget.new do
+            element 'div' do
+              element 'div'
+            end
           end
+          widget.to_s.should == '<div><div></div></div>'
         end
-        widget.to_s.should == '<div><div></div></div>'
       end
-      it "with text; returns element with inner text" do
-        Erector::Widget.new do
-          element 'div', 'test text'
-        end.to_s.should == "<div>test text</div>"
+      context "with text" do
+        it "returns element with inner text" do
+          Erector::Widget.new do
+            element 'div', 'test text'
+          end.to_s.should == "<div>test text</div>"
+        end
       end
-      it "with object other than hash; returns element with inner text == object.to_s" do
-        object = ['a', 'b']
-        Erector::Widget.new do
-          element 'div', object
-        end.to_s.should == "<div>#{object.to_s}</div>"
+      context "with object other than hash" do
+        it "returns element with inner text == object.to_s" do
+          object = ['a', 'b']
+          Erector::Widget.new do
+            element 'div', object
+          end.to_s.should == "<div>#{object.to_s}</div>"
+        end
       end
-      it "with parameters and block; returns element with inner html and attributes" do
-        Erector::Widget.new do
-          element 'div', 'class' => "foobar" do
-            element 'span', 'style' => 'display: none;'
-          end
-        end.to_s.should == '<div class="foobar"><span style="display: none;"></span></div>'
+      context "with parameters and block" do
+        it "returns element with inner html and attributes" do
+          Erector::Widget.new do
+            element 'div', 'class' => "foobar" do
+              element 'span', 'style' => 'display: none;'
+            end
+          end.to_s.should == '<div class="foobar"><span style="display: none;"></span></div>'
+        end
       end
-      it "with content and parameters; returns element with content as inner html and attributes" do
-        Erector::Widget.new do
-          element 'div', 'test text', :style => "display: none;"
-        end.to_s.should == '<div style="display: none;">test text</div>'
+      context "with content and parameters" do
+        it "returns element with content as inner html and attributes" do
+          Erector::Widget.new do
+            element 'div', 'test text', :style => "display: none;"
+          end.to_s.should == '<div style="display: none;">test text</div>'
+        end
       end
-      it "with more than three arguments; raises ArgumentError" do
-        proc do
-          Erector::Widget.new do
-            element 'div', 'foobar', {}, 'fourth'
-          end.to_s
-        end.should raise_error(ArgumentError)
+      context "with more than three arguments" do
+        it "raises ArgumentError" do
+          proc do
+            Erector::Widget.new do
+              element 'div', 'foobar', {}, 'fourth'
+            end.to_s
+          end.should raise_error(ArgumentError)
+        end
       end
       it "renders the proper full tags" do
@@ -126,79 +228,94 @@ module WidgetSpec
         end
       end
-      it "when outputting text; quotes it" do
-        Erector::Widget.new do
-          element 'div', 'test &<>text'
-        end.to_s.should == "<div>test &amp;&lt;&gt;text</div>"
-      end
-      it "when outputting text via text; quotes it" do
-        Erector::Widget.new do
-          element 'div' do
-            text "test &<>text"
+      describe "quoting" do
+        context "when outputting text" do
+          it "quotes it" do
+            Erector::Widget.new do
+              element 'div', 'test &<>text'
+            end.to_s.should == "<div>test &amp;&lt;&gt;text</div>"
           end
-        end.to_s.should == "<div>test &amp;&lt;&gt;text</div>"
-      end
+        end
-      it "when outputting attribute value; quotes it" do
-        Erector::Widget.new do
-          element 'a', :href => "foo.cgi?a&b"
-        end.to_s.should == "<a href=\"foo.cgi?a&amp;b\"></a>"
-      end
+        context "when outputting text via text" do
+          it "quotes it" do
+            Erector::Widget.new do
+              element 'div' do
+                text "test &<>text"
+              end
+            end.to_s.should == "<div>test &amp;&lt;&gt;text</div>"
+          end
+        end
-      it "with raw text, does not quote it" do
-        Erector::Widget.new do
-          element 'div' do
-            text raw("<b>bold</b>")
+        context "when outputting attribute value" do
+          it "quotes it" do
+            Erector::Widget.new do
+              element 'a', :href => "foo.cgi?a&b"
+            end.to_s.should == "<a href=\"foo.cgi?a&amp;b\"></a>"
           end
-        end.to_s.should == "<div><b>bold</b></div>"
-      end
+        end
-      it "with raw text and no block, does not quote it" do
-        Erector::Widget.new do
-          element 'div', raw("<b>bold</b>")
-        end.to_s.should == "<div><b>bold</b></div>"
-      end
+        context "with raw text" do
+          it "does not quote it" do
+            Erector::Widget.new do
+              element 'div' do
+                text raw("<b>bold</b>")
+              end
+            end.to_s.should == "<div><b>bold</b></div>"
+          end
+        end
-      it "with raw attribute, does not quote it" do
-        Erector::Widget.new do
-          element 'a', :href => raw("foo?x=&nbsp;")
-        end.to_s.should == "<a href=\"foo?x=&nbsp;\"></a>"
-      end
+        context "with raw text and no block" do
+          it "does not quote it" do
+            Erector::Widget.new do
+              element 'div', raw("<b>bold</b>")
+            end.to_s.should == "<div><b>bold</b></div>"
+          end
+        end
-      it "with quote in attribute, quotes it" do
-        Erector::Widget.new do
-          element 'a', :onload => "alert(\"foo\")"
-        end.to_s.should == "<a onload=\"alert(&quot;foo&quot;)\"></a>"
-      end
+        context "with raw attribute" do
+          it "does not quote it" do
+            Erector::Widget.new do
+              element 'a', :href => raw("foo?x=&nbsp;")
+            end.to_s.should == "<a href=\"foo?x=&nbsp;\"></a>"
+          end
+        end
-      it "with a non-string, non-raw, calls to_s and quotes" do
-        Erector::Widget.new do
-          element 'a' do
-            text [7, "foo&bar"]
+        context "with quote in attribute" do
+          it "quotes it" do
+            Erector::Widget.new do
+              element 'a', :onload => "alert(\"foo\")"
+            end.to_s.should == "<a onload=\"alert(&quot;foo&quot;)\"></a>"
           end
-        end.to_s.should == "<a>7foo&amp;bar</a>"
+        end
       end
-      it "calls to_s" do
-        Erector::Widget.new do
-          img :width=>50
-        end.to_s.should == "<img width=\"50\" />"
+      context "with a non-string, non-raw" do
+        it "calls to_s and quotes" do
+          Erector::Widget.new do
+            element 'a' do
+              text [7, "foo&bar"]
+            end
+          end.to_s.should == "<a>7foo&amp;bar</a>"
+        end
       end
     end
     describe "#empty_element" do
-      it "when receiving attributes, renders an empty element with the attributes" do
-        Erector::Widget.new do
-          empty_element 'input', :name => 'foo[bar]'
-        end.to_s.should == '<input name="foo[bar]" />'
+      context "when receiving attributes" do
+        it "renders an empty element with the attributes" do
+          Erector::Widget.new do
+            empty_element 'input', :name => 'foo[bar]'
+          end.to_s.should == '<input name="foo[bar]" />'
+        end
       end
-      it "when not receiving attributes, renders an empty element without attributes" do
-        Erector::Widget.new do
-          empty_element 'br'
-        end.to_s.should == '<br />'
+      context "when not receiving attributes" do
+        it "renders an empty element without attributes" do
+          Erector::Widget.new do
+            empty_element 'br'
+          end.to_s.should == '<br />'
+        end
       end
       it "renders the proper empty-element tags" do
@@ -217,7 +334,7 @@ module WidgetSpec
       end
     end
-    describe "nbsp" do
+    describe "#nbsp" do
       it "turns consecutive spaces into consecutive non-breaking spaces" do
         Erector::Widget.new do
           text nbsp("a  b")
@@ -237,7 +354,51 @@ module WidgetSpec
           element 'a', :href => nbsp("&<> foo")
         end.to_s.should == "<a href=\"&amp;&lt;&gt;&#160;foo\"></a>"
       end
+      it "defaults to a single non-breaking space if given no argument" do
+        Erector::Widget.new do
+          text nbsp
+        end.to_s.should == "&#160;"
+      end
+    end
+    describe "#character" do
+      it "renders a character given the codepoint number" do
+        Erector::Widget.new do
+          text character(160)
+        end.to_s.should == "&#xa0;"
+      end
+      it "renders a character given the unicode name" do
+        Erector::Widget.new do
+          text character(:right_arrow)
+        end.to_s.should == "&#x2192;"
+      end
+      it "renders a character above 0xffff" do
+        Erector::Widget.new do
+          text character(:old_persian_sign_ka)
+        end.to_s.should == "&#x103a3;"
+      end
+      it "throws an exception if a name is not recognized" do
+        lambda {
+          Erector::Widget.new do
+            text character(:no_such_character_name)
+          end.to_s
+        }.should raise_error("Unrecognized character no_such_character_name")
+      end
+      it "throws an exception if passed something besides a symbol or integer" do
+        # Perhaps calling to_s would be more ruby-esque, but that seems like it might
+        # be pretty confusing when this method can already take either a name or number
+        lambda {
+          Erector::Widget.new do
+            text character([])
+          end.to_s
+        }.should raise_error("Unrecognized argument to character: ")
+      end
     end
     describe '#h' do
@@ -255,68 +416,71 @@ module WidgetSpec
     end
     describe "#javascript" do
-      it "when receiving a block; renders the content inside of script text/javascript tags" do
-        Erector::Widget.new do
-          javascript do
-            rawtext 'if (x < y && x > z) alert("don\'t stop");'
-          end
-        end.to_s.should == <<EXPECTED
-<script type="text/javascript">
-// <![CDATA[
-if (x < y && x > z) alert("don't stop");
-// ]]>
-</script>
-EXPECTED
+      context "when receiving a block" do
+        it "renders the content inside of script text/javascript tags" do
+          expected = <<-EXPECTED
+            <script type="text/javascript">
+            // <![CDATA[
+            if (x < y && x > z) alert("don't stop");
+            // ]]>
+            </script>
+          EXPECTED
+          expected.gsub!(/^            /, '')
+          Erector::Widget.new do
+            javascript do
+              rawtext 'if (x < y && x > z) alert("don\'t stop");'
+            end
+          end.to_s.should == expected
+        end
       end
       it "renders the raw content inside script tags when given text" do
+        expected = <<-EXPECTED
+          <script type="text/javascript">
+          // <![CDATA[
+          alert("&<>'hello");
+          // ]]>
+          </script>
+        EXPECTED
+        expected.gsub!(/^          /, '')
         Erector::Widget.new do
           javascript('alert("&<>\'hello");')
-        end.to_s.should == <<EXPECTED
-<script type="text/javascript">
-// <![CDATA[
-alert("&<>'hello");
-// ]]>
-</script>
-EXPECTED
+        end.to_s.should == expected
       end
-      it "when receiving a params hash; renders a source file" do
-        html = Erector::Widget.new do
-          javascript(:src => "/my/js/file.js")
-        end.to_s
-        doc = Hpricot(html)
-        doc.at('/')[:src].should == "/my/js/file.js"
-      end
-      it "when receiving text and a params hash; renders a source file" do
-        html = Erector::Widget.new do
-          javascript('alert("&<>\'hello");', :src => "/my/js/file.js")
-        end.to_s
-        doc = Hpricot(html)
-        script_tag = doc.at('script')
-        script_tag[:src].should == "/my/js/file.js"
-        script_tag.inner_html.should include('alert("&<>\'hello");')
+      context "when receiving a params hash" do
+        it "renders a source file" do
+          html = Erector::Widget.new do
+            javascript(:src => "/my/js/file.js")
+          end.to_s
+          doc = Hpricot(html)
+          doc.at('/')[:src].should == "/my/js/file.js"
+        end
       end
-      it "with too many arguments; raises ArgumentError" do
-        proc do
-          Erector::Widget.new do
-            javascript 'foobar', {}, 'fourth'
+      context "when receiving text and a params hash" do
+        it "renders a source file" do
+          html = Erector::Widget.new do
+            javascript('alert("&<>\'hello");', :src => "/my/js/file.js")
           end.to_s
-        end.should raise_error(ArgumentError)
+          doc = Hpricot(html)
+          script_tag = doc.at('script')
+          script_tag[:src].should == "/my/js/file.js"
+          script_tag.inner_html.should include('alert("&<>\'hello");')
+        end
       end
-      it "script method doesn't do any magic" do
-        Erector::Widget.new do
-          script(:type => "text/javascript") do
-            rawtext "if (x < y || x > z) onEnterGetTo('/search?a=b&c=d')"
-          end
-        end.to_s.should == "<script type=\"text/javascript\">if (x < y || x > z) onEnterGetTo('/search?a=b&c=d')</script>"
+      context "with too many arguments" do
+        it "raises ArgumentError" do
+          proc do
+            Erector::Widget.new do
+              javascript 'foobar', {}, 'fourth'
+            end.to_s
+          end.should raise_error(ArgumentError)
+        end
       end
     end
     describe "#css" do
       it "makes a link when passed a string" do
         Erector::Widget.new do
@@ -324,7 +488,7 @@ EXPECTED
         end.to_s.should == "<link href=\"erector.css\" rel=\"stylesheet\" type=\"text/css\" />"
       end
     end
     describe "#url" do
       it "renders an anchor tag with the same href and text" do
         Erector::Widget.new do
@@ -402,7 +566,7 @@ EXPECTED
         Parent.new.to_s.should == '123'
       end
     end
     describe '#render_to' do
       class A < Erector::Widget
         def render
@@ -420,9 +584,9 @@ EXPECTED
         end
         b = B.new
         b.to_s.should == "B<p>A</p>B"
-        b.doc.size.should == 5  # B, <p>, A, </p>, B
+        b.doc.size.should == 10  # B, <p>, A, </p>, B
       end
       it "renders to a widget's doc" do
         class B < Erector::Widget
           def render
@@ -433,9 +597,9 @@ EXPECTED
         end
         b = B.new
         b.to_s.should == "B<p>A</p>B"
-        b.doc.size.should == 5  # B, <p>, A, </p>, B
+        b.doc.size.should == 10  # B, <p>, A, </p>, B
       end
       it "passing a widget to text method renders it" do
         Erector::Widget.new() do
           text "B"