pivotal-erector 0.5.1

data/spec/core_spec_suite.rb

@@ -0,0 +1,3 @@
+dir = File.dirname(__FILE__)
+require "#{dir}/spec_suite"
+SpecSuite.core

data/spec/erect/erect_spec.rb

@@ -0,0 +1,145 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../spec_helper")
+
+module Erector
+  describe Erect do
+    it "parses an empty command line" do
+      erect = Erect.new([])
+      erect.files.should == []
+    end
+    
+    it "parses a command line with one filename on it" do
+      erect = Erect.new(["foo.html"])
+      erect.files.should == ["foo.html"]
+    end
+    
+    it "parses a command line with several filenames on it" do
+      erect = Erect.new(["foo.html", "bar/baz.html"])
+      erect.files.should == ["foo.html", "bar/baz.html"]
+    end
+    
+    it "is verbose by default, but quiet when told" do
+      Erect.new([]).verbose.should be_true
+      Erect.new(["-q"]).verbose.should be_false
+    end
+
+    it "parses a command line with several filenames and an option on it" do
+      erect = Erect.new(["-q", "foo.html", "bar/baz.html"])
+      erect.files.should == ["foo.html", "bar/baz.html"]
+    end
+ 
+    def capture
+      output = StringIO.new
+      $stdout = output
+      yield
+      output.string
+    ensure
+      $stdout = STDOUT
+    end
+    
+    it "exits immediately from help" do
+      output = capture do
+        lambda {
+          erect = Erect.new(["-h"])
+        }.should raise_error(SystemExit)
+      end
+      output.should =~ /^Usage/
+    end
+    
+    it "exits immediately from --version" do
+      output = capture do
+        lambda {
+          erect = Erect.new(["--version"])
+        }.should raise_error(SystemExit)
+      end
+      output.should == Erector::VERSION + "\n"
+    end
+    
+    it "changes to html output" do
+      erect = Erect.new(["--to-html"])
+      erect.mode.should == :to_html
+    end
+
+  end
+  
+  describe "Erect functionally" do
+    
+    attr_reader :dir, :fred_html, :wilma_rhtml, :barney_html_erb, :fred_rb
+    
+    def create(file, body="hi")
+      File.open(file, "w") do |f|
+        f.puts(body)
+      end
+    end
+    
+    before :all do
+      @dir = Dir.tmpdir + "/#{Time.now.to_i}" + "/explode"
+      @fred_html = "#{dir}/fred.html"
+      @wilma_rhtml = "#{dir}/wilma.rhtml"
+      @barney_html_erb = "#{dir}/barney.html.erb"
+      @fred_rb = "#{dir}/fred.rb"
+
+      FileUtils.mkdir_p(dir)
+      create(fred_html)
+      create(wilma_rhtml)
+      create(barney_html_erb)
+      create(fred_rb, "class Fred < Erector::Widget\ndef render\ndiv 'dino'\nend\nend")
+    end
+    
+    it "explodes dirs into .html etc. files when in to-rb mode" do
+      erect = Erect.new(["--to-erector", dir])
+      erect.files.sort.should == [barney_html_erb, fred_html, wilma_rhtml]
+    end
+    
+    it "explodes dirs into .rb files when in to-html mode" do    
+      erect = Erect.new(["--to-html", dir])
+      erect.files.should == [fred_rb]
+    end
+    
+    it "outputs .rb files in the same directory as the input .html files" do
+      erect = Erect.new(["--to-erector", "-q", fred_html])
+      erect.run
+      File.exist?(fred_rb).should be_true
+      File.read(fred_rb).should include("text 'hi'")
+    end
+    
+    it "outputs .html files in the same directory as the input .rb files" do
+      betty_rb = "#{dir}/betty.rb"
+      betty_html = "#{dir}/betty.html"
+      create(betty_rb, "class Betty < Erector::Widget\ndef render\ndiv 'bam bam'\nend\nend")
+
+      erect = Erect.new(["--to-html", "-q", betty_rb])
+      erect.run
+      File.exist?(betty_html).should be_true
+      File.read(betty_html).should == "<div>bam bam</div>\n"
+    end
+    
+    it "outputs .html files in the given directory" do
+      create(fred_rb, "class Fred < Erector::Widget\ndef render\ndiv 'dino'\nend\nend")
+      
+      
+      out_dir = "#{dir}/out"
+      out_file = "#{out_dir}/fred.html"
+      Erect.new([]).output_dir.should be_nil
+      erect = Erect.new(["--to-html", "-o", "#{out_dir}", "-q", fred_rb])
+      erect.output_dir.should == out_dir
+      erect.run
+      File.exist?(out_file).should be_true
+      File.read(out_file).should == "<div>dino</div>\n"
+    end
+    
+    it "supports the --add-to-svn option"
+    it "supports the --delete-original option"
+
+    it "skips rendering classes that aren't widgets" do
+      mr_slate_rb = "#{dir}/mr_slate.rb"
+      mr_slate_html = "#{dir}/mr_slate.html"
+      create(mr_slate_rb, "class MrSlate\nend")
+      erect = Erect.new(["-q", "--to-html", mr_slate_rb])
+      erect.run
+      File.exist?(mr_slate_html).should be_false
+    end
+    
+    it "properly indents lines beginning with for, unless, etc."
+    it "escapes single quotes inside text strings"
+  end
+end

data/spec/erect/erected_spec.rb

@@ -0,0 +1,80 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../spec_helper")
+
+module Erector
+  describe Erected do
+
+    it "picks the right file name" do
+      Erected.new("foo.html.erb").filename.should == "foo.rb"
+      Erected.new("foo.html").filename.should == "foo.rb"
+      Erected.new("foo.bar.html").filename.should == "foo.rb"
+      Erected.new("foo_bar.html.erb").filename.should == "foo_bar.rb"
+      Erected.new("stuff/foo_bar.html.erb").filename.should == "stuff/foo_bar.rb"
+    end
+
+    it "picks a nice class name" do
+      Erected.new("foo.html.erb").classname.should == "Foo"
+      Erected.new("foo.html").classname.should == "Foo"
+      Erected.new("foo.bar.html").classname.should == "Foo"
+      Erected.new("foo_bar.html.erb").classname.should == "FooBar"
+      Erected.new("stuff/foo_bar.html.erb").classname.should == "FooBar"
+    end
+
+    it "picks an even nicer class name if it's in a views dir" do
+      Erected.new("app/views/stuff/foo_bar.html.erb").classname.should == "Views::Stuff::FooBar"
+      Erected.new("views/stuff/foo_bar.html.erb").classname.should == "Views::Stuff::FooBar"
+    end
+
+    def convert(dir, input, output)
+      dir = Dir.tmpdir + "/#{Time.now.to_i}" + "/#{dir}"
+
+      FileUtils.mkdir_p(dir)
+      html = "#{dir}/dummy.html"
+      rb = "#{dir}/dummy.rb"
+
+      File.open(html, "w") do |f|
+        f.puts(input)
+      end
+
+      @e = Erected.new(html)
+      @e.convert
+
+      File.read(rb).should == output
+    end
+
+    it "converts a normal file" do
+      convert(".",
+        "<div>hello</div>",
+        "class Dummy < Erector::Widget\n" +
+          "  def render\n" +
+          "    div do\n" +
+          "      text 'hello'\n" +
+          "    end\n" +
+          "  end\n" +
+          "end\n"
+      )
+    end
+
+    it "converts a views file" do
+      convert("app/views/foos",
+        "<div>hello</div>",
+        "class Views::Foos::Dummy < Erector::Widget\n" +
+          "  def render\n" +
+          "    div do\n" +
+          "      text 'hello'\n" +
+          "    end\n" +
+          "  end\n" +
+          "end\n"
+      )
+    end
+
+# todo: figure out if there is any such thing as unparsable HTML anymore
+#    it "raises an exception if given unparsable HTML" do
+#      begin
+#        convert(".", "<", "")
+#      rescue => e
+#        e.to_s.should include("Could not parse")
+#      end
+#    end
+    
+  end
+end

data/spec/erect/rhtml_parser_spec.rb

@@ -0,0 +1,318 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../spec_helper")
+
+module ParserTestHelper
+  def assert_evals_to_self(input)
+    assert_evals_to(input, input)
+  end
+
+  def parse(input)
+    result = @parser.parse(input)
+    if result
+      result.set_indent(0) if result.respond_to? :set_indent
+    else
+      puts @parser.failure_reason
+      puts @parser.terminal_failures.join("\n")
+      result.should_not be_nil
+    end
+    result
+  end
+end
+
+describe RhtmlParser do
+  include ParserTestHelper
+  
+  before :each do
+    @parser = RhtmlParser.new
+  end
+  
+  it "converts text" do
+    parse("hello").convert.should == "text 'hello'\n"
+    parse("hello maude!").convert.should == "text 'hello maude!'\n"
+    parse(" hello ").convert.should == "text 'hello'\n"
+  end
+  
+  it "unescapes HTML entities in text" do
+      parse("&lt;").convert.should == "text '<'\n"
+      parse("5 &gt; 2").convert.should == "text '5 > 2'\n"
+  end
+
+  it "converts self-closing tags" do
+    parse("<br/>").convert.should == "br\n"
+    parse("<br />").convert.should == "br\n"
+  end
+
+  it "converts open tag" do
+    parse("<div>").convert.should == "div do\n"
+    parse("<h1>").convert.should == "h1 do\n"
+  end
+
+  it "converts close tag" do
+    parse("</div>").convert.should == "end\n"
+    parse("</h1>").convert.should == "end\n"
+  end
+
+  it "converts two nested divs" do
+    parse("<div><div></div></div>").convert.should ==
+      "div do\n" +
+      "  div do\n" +
+      "  end\n" +
+      "end\n"
+  end
+
+  it "converts two nested divs with whitespace" do
+    parse("<div> <div> </div> </div>").convert.should ==
+      "div do\n" +
+      "  div do\n" +
+      "  end\n" +
+      "end\n"
+  end
+
+  it "converts no open, text, and no close tag" do
+    parse("hello</div>").convert.should == "text 'hello'\nend\n"
+  end
+
+  it "converts open, text, and no close tag" do
+    parse("<div>hello").convert.should == "div do\n  text 'hello'\n"
+  end
+
+  it "converts open, text, close" do
+    parse("<div>hello</div>").convert.should == "div do\n  text 'hello'\nend\n"
+  end
+  
+  it "autocloses an img tag" do
+    parse("<img src='foo'>").convert.should == "img :src => 'foo'\n"
+  end
+
+  it "converts a scriptlet" do
+    parse("<% foo %>").convert.should == "foo\n"
+  end
+
+  it "converts open, text, scriptlet, text, close" do
+    parse("<div>hello <% 5.times do %> very <% end %> much</div>").convert.should ==
+      "div do\n" +
+      "  text 'hello'\n" +
+      "  5.times do\n" +
+      "    text 'very'\n" +
+      "  end\n" +
+      "  text 'much'\n" +
+      "end\n"
+  end
+
+  it "converts open, scriptlet, text, close" do
+    parse("<div><% 5.times do %> very <% end %> much</div>").convert.should ==
+      "div do\n" +
+      "  5.times do\n" +
+      "    text 'very'\n" +
+      "  end\n" +
+      "  text 'much'\n" +
+      "end\n"
+  end
+
+  it "converts open, text, scriptlet, close" do
+    parse("<div>hello <% 5.times do %> very <% end %></div>").convert.should ==
+      "div do\n" +
+      "  text 'hello'\n" +
+      "  5.times do\n" +
+      "    text 'very'\n" +
+      "  end\n" +
+      "end\n"
+  end
+
+  it "converts printlets into rawtext statements" do
+    parse("<%= 1+1 %>").convert.should == "rawtext 1+1\n"
+    parse("<%= link_to \"mom\" %>").convert.should == "rawtext link_to(\"mom\")\n"
+  end
+
+  it "converts h-printlets into text statements" do
+    parse("<%=h foo %>").convert.should == "text foo\n"
+    parse("<%= h \"mom\" %>").convert.should == "text \"mom\"\n"
+  end
+
+  it "allows naked percent signs inside scriptlets" do
+      parse("<% x = 10 % 5 %>").convert.should == "x = 10 % 5\n"
+  end
+
+  it "indents" do
+    i = Erector::Indenting.new(nil, nil)
+    i.line("foo").should ==     "foo\n"
+    i.line_in("bar").should ==  "bar\n"
+    i.line_in("baz").should ==  "  baz\n"
+    i.line("baf").should ==     "    baf\n"
+    i.line_out("end").should == "  end\n"
+    i.line_out("end").should == "end\n"
+  end
+
+  it "indents extra when told to" do
+    parse("<div>hello</div>").set_indent(2).convert.should ==
+      "    div do\n" +
+      "      text 'hello'\n" +
+      "    end\n"
+  end
+
+  it "indents scriptlets ending with do and end" do
+    parse("<% form_for :foo do |x,y| %><% 5.times do %>hello<% end %><% end %>bye").convert.should ==
+      "form_for :foo do |x,y|\n" +
+      "  5.times do\n" +
+      "    text 'hello'\n" +
+      "  end\n" +
+      "end\n" +
+      "text 'bye'\n"
+  end
+
+  it "converts HTML attributes" do
+    parse("<div id='foo'/>").convert.should == "div :id => 'foo'\n"
+    parse("<div id='foo' class='bar'/>").convert.should == "div :id => 'foo', :class => 'bar'\n"
+    parse("<div id='foo'>bar</div>").convert.should == "div :id => 'foo' do\n  text 'bar'\nend\n"    
+  end
+  
+  it "escapes single quotes inside attribute values" do
+    @parser.root = :attribute
+    parse("a=\"don't worry\"").convert.should == ":a => 'don\\'t worry'"
+  end
+
+  it "allows newlines where whitespace is allowed" do
+    parse("<img src='foo' \nalt='bar' />").convert.should == "img :src => 'foo', :alt => 'bar'\n"
+  end
+  
+  it "treats tab characters the same as spaces" do
+    parse("<div \t />").convert.should == "div\n"
+  end
+  
+  it "deals with HTML entities in text" do
+    parse("&lt;").convert.should == "text '<'\n"
+  end
+
+  it "deals with a naked less-than or greater-than sign inside text" do
+    parse("if x > 2 or x< 5 then").convert.should == "text 'if x > 2 or x< 5 then'\n"
+  end
+
+  it "wraps printlets in parens if necessary, to avoid warning: parenthesize argument(s) for future version" do
+    parse("<%= h \"mom\" %>").convert.should == "text \"mom\"\n"
+    parse("<%= h hi \"mom\" %>").convert.should == "text hi(\"mom\")\n"
+
+    parse("<%= \"mom\" %>").convert.should == "rawtext \"mom\"\n"
+    parse("<%= \"hi mom\" %>").convert.should == "rawtext \"hi mom\"\n"
+    parse("<%= hi \"mom\" %>").convert.should == "rawtext hi(\"mom\")\n"
+
+    parse("<%= link_to blah %>").convert.should == "rawtext link_to(blah)\n"
+    parse("<%= link_to blah blah %>").convert.should == "rawtext link_to(blah blah)\n"
+    parse("<%= link_to blah(blah) %>").convert.should == "rawtext link_to(blah(blah))\n"
+
+    parse("<%= link_to(blah) %>").convert.should == "rawtext link_to(blah)\n"
+  end
+  
+  it "won't parenthesize expressions" do
+    parse("<%= h foo / bar %>").convert.should == "text foo / bar\n"
+  end
+  
+  it "converts yield so layouts work" do
+    pending("easy enough to make this pass, but the result doesn't seem to work as a layout")
+    parse("<%= yield  %>").convert.should == "rawtext @content\n"
+    parse("<%= \"yield\" %>").convert.should == "rawtext \"yield\"\n"
+    parse("<%= \"the yield is good\" %>").convert.should == "rawtext \"the yield is good\"\n"
+  end
+  
+  it "parses quoted strings" do
+    @parser.root = :quoted
+    parse("'foo'").value.should == "foo"
+    parse("\"foo\"").value.should == "foo"
+  end
+
+  it "converts attributes in isolation" do
+    @parser.root = :attribute
+    parse("a='foo'").convert.should == ":a => 'foo'"
+    parse("a=\"foo\"").convert.should == ":a => 'foo'"
+  end
+  
+  it "parses a set of attributes" do
+    @parser.root = :attributes
+    parse("a='foo' b='bar'").convert.should == " :a => 'foo', :b => 'bar'"
+  end
+  
+  it "works with namespaced attributes" do
+    @parser.root = :attribute
+    parse('xml:lang="en"').convert.should == "'xml:lang' => 'en'"
+  end
+  
+  it "deals with HTML entities in attribute values" do
+    @parser.root = :attribute
+    parse("foo='b<r'").convert.should == ":foo => 'b<r'"
+    parse("foo='b&lt;r'").convert.should == ":foo => 'b<r'"
+  end
+
+  it "converts DOCTYPEs" do
+    html = '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+           "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">'
+    parse(html).convert.should == "rawtext '#{html}'\n"
+  end
+  
+  ## More functional-type specs below here
+
+  it "ignores spaces, tabs and newlines" do
+    parse("  <div>\t\n" + "\thello !" + "\n\t</div>").convert.should ==
+      "div do\n" +
+      "  text 'hello !'\n" +
+      "end\n"
+  end
+
+  it "parses some scaffolding" do
+    parse("<p>
+  <b>Name:</b>
+  <%=h @foo.name %>
+</p>").convert.should ==
+      "p do\n" +
+      "  b do\n" +
+      "    text 'Name:'\n" +
+      "  end\n" +
+      "  text @foo.name\n" +
+      "end\n"
+  end
+
+  it "parses edit.erb.html" do
+    parse("<h1>Editing foo</h1>
+
+<%= error_messages_for :foo %>
+
+<% form_for(@foo) do |f| %>
+  <p>
+    <b>Name</b><br />
+    <%= f.text_field :name %>
+  </p>
+
+  <p>
+    <b>Age</b><br />
+    <%= f.text_field :age %>
+  </p>
+
+  <p>
+    <%= f.submit \"Update\" %>
+  </p>
+<% end %>
+
+<%= link_to 'Show', @foo %> |
+<%= link_to 'Back', foos_path %>
+")
+  end
+
+  it "parses show.html.erb" do
+    parse("<p>
+  <b>Name:</b>
+  <%=h @foo.name %>
+</p>
+
+<p>
+  <b>Age:</b>
+  <%=h @foo.age %>
+</p>
+
+
+<%= link_to 'Edit', edit_foo_path(@foo) %> |
+<%= link_to 'Back', foos_path %>
+")
+  end
+
+  it "does meta" do
+    parse('<meta http-equiv="content-type" content="text/html;charset=UTF-8" />').convert.should ==
+    "meta 'http-equiv' => 'content-type', :content => 'text/html;charset=UTF-8'\n"
+  end
+end

data/spec/erector/indentation_spec.rb

@@ -0,0 +1,136 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../spec_helper")
+
+describe "indentation" do
+
+  it "can detect newliney tags" do
+    widget = ::Erector::Widget.new
+    string = widget.output
+    widget.enable_prettyprint = true
+    widget.newliney("i").should == false
+    widget.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
+  
+  it "can turn newlines on/off via global variable" do
+    Erector::Widget.new { br }.to_s.should == "<br />"
+    Erector::Widget.prettyprint_default = true
+    Erector::Widget.new { br }.to_s.should == "<br />\n"
+    Erector::Widget.prettyprint_default = false
+    Erector::Widget.new { br }.to_s.should == "<br />"
+  end
+  
+end
+