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

erector 0.3.110 → 0.4.191

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"