html2haml 1.0.0.beta.1

data/lib/html2haml/html/erb.rb

@@ -0,0 +1,153 @@
+require 'cgi'
+require 'erubis'
+require 'ruby_parser'
+
+module Haml
+  class HTML
+    # A class for converting ERB code into a format that's easier
+    # for the {Haml::HTML} Hpricot-based parser to understand.
+    #
+    # Uses [Erubis](http://www.kuwata-lab.com/erubis)'s extensible parsing powers
+    # to parse the ERB in a reliable way,
+    # and [ruby_parser](http://parsetree.rubyforge.org/)'s Ruby knowledge
+    # to figure out whether a given chunk of Ruby code starts a block or not.
+    #
+    # The ERB tags are converted to HTML tags in the following way.
+    # `<% ... %>` is converted into `<haml:silent> ... </haml:silent>`.
+    # `<%= ... %>` is converted into `<haml:loud> ... </haml:loud>`.
+    # Finally, if either of these opens a Ruby block,
+    # `<haml:block> ... </haml:block>` will wrap the entire contents of the block -
+    # that is, everything that should be indented beneath the previous silent or loud tag.
+    class ERB < Erubis::Basic::Engine
+      # Compiles an ERB template into a HTML document containing `haml:` tags.
+      #
+      # @param template [String] The ERB template
+      # @return [String] The output document
+      # @see Haml::HTML::ERB
+      def self.compile(template)
+        new(template).src
+      end
+
+      # `html2haml` doesn't support HTML-escaped expressions.
+      def escaped_expr(code)
+        raise Haml::Error.new("html2haml doesn't support escaped expressions.")
+      end
+
+      # The ERB-to-Hamlized-HTML conversion has no preamble.
+      def add_preamble(src); end
+
+      # The ERB-to-Hamlized-HTML conversion has no postamble.
+      def add_postamble(src); end
+
+      # Concatenates the text onto the source buffer.
+      #
+      # @param src [String] The source buffer
+      # @param text [String] The raw text to add to the buffer
+      def add_text(src, text)
+        src << text
+      end
+
+      # Concatenates a silent Ruby statement onto the source buffer.
+      # This uses the `<haml:silent>` tag,
+      # and may close and/or open a Ruby block with the `<haml:block>` tag.
+      #
+      # In particular, a block is closed if this statement is some form of `end`,
+      # opened if it's a block opener like `do`, `if`, or `begin`,
+      # and both closed and opened if it's a mid-block keyword
+      # like `else` or `when`.
+      #
+      # @param src [String] The source buffer
+      # @param code [String] The Ruby statement to add to the buffer
+      def add_stmt(src, code)
+        src << '</haml:block>' if block_closer?(code) || mid_block?(code)
+        src << '<haml:silent>' << h(code) << '</haml:silent>' unless code.strip == "end"
+        src << '<haml:block>' if block_opener?(code) || mid_block?(code)
+      end
+
+      # Concatenates a Ruby expression that's printed to the document
+      # onto the source buffer.
+      # This uses the `<haml:silent>` tag,
+      # and may open a Ruby block with the `<haml:block>` tag.
+      # An expression never closes a block.
+      #
+      # @param src [String] The source buffer
+      # @param code [String] The Ruby expression to add to the buffer
+      def add_expr_literal(src, code)
+        src << '<haml:loud>' << h(code) << '</haml:loud>'
+        src << '<haml:block>' if block_opener?(code)
+      end
+
+      # `html2haml` doesn't support debugging expressions.
+      def add_expr_debug(src, code)
+        raise Haml::Error.new("html2haml doesn't support debugging expressions.")
+      end
+
+      private
+
+      # HTML-escaped some text (in practice, always Ruby code).
+      # A utility method.
+      #
+      # @param text [String] The text to escape
+      # @return [String] The escaped text
+      def h(text)
+        CGI.escapeHTML(text)
+      end
+
+      # Returns whether the code is valid Ruby code on its own.
+      #
+      # @param code [String] Ruby code to check
+      # @return [Boolean]
+      def valid_ruby?(code)
+        RubyParser.new.parse(code)
+      rescue Racc::ParseError
+        false
+      end
+
+      # Returns whether the code has any content
+      # This is used to test whether lines have been removed by erubis, such as comments
+      #
+      # @param code [String] Ruby code to check
+      # @return [Boolean]
+      def has_code?(code)
+        code != "\n"
+      end
+
+      # Checks if a string of Ruby code opens a block.
+      # This could either be something like `foo do |a|`
+      # or a keyword that requires a matching `end`
+      # like `if`, `begin`, or `case`.
+      #
+      # @param code [String] Ruby code to check
+      # @return [Boolean]
+      def block_opener?(code)
+        return unless has_code?(code)
+        valid_ruby?(code + "\nend") ||
+          valid_ruby?(code + "\nwhen foo\nend")
+      end
+
+      # Checks if a string of Ruby code closes a block.
+      # This is always `end` followed optionally by some method calls.
+      #
+      # @param code [String] Ruby code to check
+      # @return [Boolean]
+      def block_closer?(code)
+        return unless has_code?(code)
+        valid_ruby?("begin\n" + code)
+      end
+
+      # Checks if a string of Ruby code comes in the middle of a block.
+      # This could be a keyword like `else`, `rescue`, or `when`,
+      # or even `end` with a method call that takes a block.
+      #
+      # @param code [String] Ruby code to check
+      # @return [Boolean]
+      def mid_block?(code)
+        return unless has_code?(code)
+        return if valid_ruby?(code)
+        valid_ruby?("if foo\n#{code}\nend") || # else, elsif
+          valid_ruby?("begin\n#{code}\nend") || # rescue, ensure
+          valid_ruby?("case foo\n#{code}\nend") # when
+      end
+    end
+  end
+end

data/lib/html2haml/version.rb

@@ -0,0 +1,3 @@
+module Html2haml
+  VERSION = "1.0.0.beta.1"
+end

data/test/erb_test.rb

@@ -0,0 +1,477 @@
+require 'test_helper'
+
+class ErbTest < MiniTest::Unit::TestCase
+  def test_erb
+    assert_equal '- foo = bar', render_erb('<% foo = bar %>')
+    assert_equal '- foo = bar', render_erb('<% foo = bar -%>')
+    assert_equal '= h @item.title', render_erb('<%=h @item.title %>')
+    assert_equal '= h @item.title', render_erb('<%=h @item.title -%>')
+  end
+
+  def test_inline_erb
+    assert_equal("%p= foo", render_erb("<p><%= foo %></p>"))
+  end
+
+  def test_non_inline_erb
+    assert_equal(<<HAML.rstrip, render_erb(<<HTML))
+%p
+  = foo
+HAML
+<p>
+  <%= foo %>
+</p>
+HTML
+    assert_equal(<<HAML.rstrip, render_erb(<<HTML))
+%p
+  = foo
+HAML
+<p>
+  <%= foo %></p>
+HTML
+    assert_equal(<<HAML.rstrip, render_erb(<<HTML))
+%p
+  = foo
+HAML
+<p><%= foo %>
+</p>
+HTML
+  end
+
+  def test_erb_in_cdata
+    assert_equal(<<HAML.rstrip, render_erb(<<HTML))
+:cdata
+  Foo \#{bar} baz
+HAML
+<![CDATA[Foo <%= bar %> baz]]>
+HTML
+  end
+
+  def test_erb_in_script
+    assert_equal(<<HAML.rstrip, render_erb(<<HTML))
+:javascript
+  function foo() {
+    return \#{foo.to_json};
+  }
+HAML
+<script type="text/javascript">
+  function foo() {
+    return <%= foo.to_json %>;
+  }
+</script>
+HTML
+  end
+
+  def test_erb_in_style
+    assert_equal(<<HAML.rstrip, render_erb(<<HTML))
+:css
+  foo {
+      bar: \#{"baz"};
+  }
+HAML
+<style type="text/css">
+    foo {
+        bar: <%= "baz" %>;
+    }
+</style>
+HTML
+  end
+
+  def test_erb_in_line
+    assert_equal 'foo bar #{baz}', render_erb('foo bar <%= baz %>')
+    assert_equal 'foo bar #{baz}! Bang.', render_erb('foo bar <%= baz %>! Bang.')
+  end
+
+  def test_erb_multi_in_line
+    assert_equal('foo bar #{baz}! Bang #{bop}.',
+      render_erb('foo bar <%= baz %>! Bang <%= bop %>.'))
+    assert_equal('foo bar #{baz}#{bop}!',
+      render_erb('foo bar <%= baz %><%= bop %>!'))
+  end
+
+  def test_erb_with_html_special_chars
+    assert_equal '= 3 < 5 ? "OK" : "Your computer is b0rken"',
+      render_erb('<%= 3 < 5 ? "OK" : "Your computer is b0rken" %>')
+  end
+
+  def test_erb_in_class_attribute
+    assert_equal "%div{:class => dyna_class} I have a dynamic attribute",
+      render_erb('<div class="<%= dyna_class %>">I have a dynamic attribute</div>')
+  end
+
+  def test_erb_in_id_attribute
+    assert_equal "%div{:id => dyna_id} I have a dynamic attribute",
+      render_erb('<div id="<%= dyna_id %>">I have a dynamic attribute</div>')
+  end
+
+  def test_erb_in_attribute_results_in_string_interpolation
+    assert_equal('%div{:id => "item_#{i}"} Ruby string interpolation FTW',
+      render_erb('<div id="item_<%= i %>">Ruby string interpolation FTW</div>'))
+  end
+
+  def test_erb_in_attribute_with_trailing_content
+    assert_equal('%div{:class => "#{12}!"} Bang!',
+      render_erb('<div class="<%= 12 %>!">Bang!</div>'))
+  end
+
+  def test_erb_in_html_escaped_attribute
+    assert_equal '%div{:class => "foo"} Bang!',
+      render_erb('<div class="<%= "foo" %>">Bang!</div>')
+  end
+
+  def test_erb_in_attribute_to_multiple_interpolations
+    assert_equal('%div{:class => "#{12} + #{13}"} Math is super',
+      render_erb('<div class="<%= 12 %> + <%= 13 %>">Math is super</div>'))
+  end
+
+  def test_whitespace_eating_erb_tags
+    assert_equal '- form_for', render_erb('<%- form_for -%>')
+  end
+
+  def test_interpolation_in_erb
+    assert_equal('= "Foo #{bar} baz"', render_erb('<%= "Foo #{bar} baz" %>'))
+  end
+
+  def test_interpolation_in_erb_attrs
+    assert_equal('%p{:foo => "#{bar} baz"}',
+      render_erb('<p foo="<%= "#{bar} baz" %>"></p>'))
+  end
+
+  def test_multiline_erb_silent_script
+    assert_equal(<<HAML.rstrip, render_erb(<<ERB))
+.blah
+  - foo
+  - bar
+  - baz
+  %p foo
+HAML
+<div class="blah">
+  <%
+    foo
+    bar
+    baz
+  %>
+  <p>foo</p>
+</div>
+ERB
+  end
+
+  def test_multiline_erb_loud_script
+    assert_equal(<<HAML.rstrip, render_erb(<<ERB))
+.blah
+  = foo +            |
+      bar.baz.bang + |
+    baz              |
+  %p foo
+HAML
+<div class="blah">
+  <%=
+    foo +
+      bar.baz.bang +
+    baz
+  %>
+  <p>foo</p>
+</div>
+ERB
+  end
+
+  def test_weirdly_indented_multiline_erb_loud_script
+    assert_equal(<<HAML.rstrip, render_erb(<<ERB))
+.blah
+  = foo +          |
+    bar.baz.bang + |
+    baz            |
+  %p foo
+HAML
+<div class="blah">
+  <%=
+    foo +
+  bar.baz.bang +
+    baz
+  %>
+  <p>foo</p>
+</div>
+ERB
+  end
+
+  def test_two_multiline_erb_loud_scripts
+    assert_equal(<<HAML.rstrip, render_erb(<<ERB))
+.blah
+  = foo +          |
+    bar.baz.bang + |
+    baz            |
+  -#
+  = foo.bar do |
+      bang     |
+    end        |
+  %p foo
+HAML
+<div class="blah">
+  <%=
+    foo +
+    bar.baz.bang +
+    baz
+  %>
+  <%= foo.bar do
+        bang
+      end %>
+  <p>foo</p>
+</div>
+ERB
+  end
+
+  def test_multiline_then_single_line_erb_loud_scripts
+    assert_equal(<<HAML.rstrip, render_erb(<<ERB))
+.blah
+  = foo +          |
+    bar.baz.bang + |
+    baz            |
+  = foo.bar
+  %p foo
+HAML
+<div class="blah">
+  <%=
+    foo +
+    bar.baz.bang +
+    baz
+  %>
+  <%= foo.bar %>
+  <p>foo</p>
+</div>
+ERB
+  end
+
+  def test_multiline_erb_but_really_single_line
+    assert_equal(<<HAML.rstrip, render_erb(<<ERB))
+.blah
+  = foo
+  %p foo
+HAML
+<div class="blah">
+  <%=
+    foo
+  %>
+  <p>foo</p>
+</div>
+ERB
+  end
+
+  ### Block Parsing
+
+  def test_block_parsing
+    assert_equal(<<HAML.rstrip, render_erb(<<ERB))
+- foo do
+  %p bar
+HAML
+<% foo do %>
+  <p>bar</p>
+<% end %>
+ERB
+  end
+
+  def test_block_parsing_with_args
+    assert_equal(<<HAML.rstrip, render_erb(<<ERB))
+- foo do |a, b, c|
+  %p bar
+HAML
+<% foo do |a, b, c| %>
+  <p>bar</p>
+<% end %>
+ERB
+  end
+
+  def test_block_parsing_with_equals
+    assert_equal(<<HAML.rstrip, render_erb(<<ERB))
+= foo do
+  %p bar
+HAML
+<%= foo do %>
+  <p>bar</p>
+<% end %>
+ERB
+  end
+
+  def test_block_parsing_with_modified_end
+    assert_equal(<<HAML.rstrip, render_erb(<<ERB))
+- foo do
+  blah
+- end.bip
+HAML
+<% foo do %>
+  blah
+<% end.bip %>
+ERB
+  end
+
+  def test_block_parsing_with_modified_end_with_block
+    assert_equal(<<HAML.rstrip, render_erb(<<ERB))
+- foo do
+  blah
+- end.bip do
+  brang
+HAML
+<% foo do %>
+  blah
+<% end.bip do %>
+  brang
+<% end %>
+ERB
+  end
+
+  def test_multiline_block_opener
+    assert_equal(<<HAML.rstrip, render_erb(<<ERB))
+- foo bar
+- baz bang
+- biddle do
+  foo
+HAML
+<% foo bar
+  baz bang
+  biddle do %>
+    foo
+<% end %>
+ERB
+  end
+
+  def test_if_elsif_else_parsing
+    assert_equal(<<HAML.rstrip, render_erb(<<ERB))
+- if foo
+  %p bar
+- elsif bar.foo("zip")
+  #bang baz
+- else
+  %strong bibble
+HAML
+<% if foo %>
+  <p>bar</p>
+<% elsif bar.foo("zip") %>
+  <div id="bang">baz</div>
+<% else %>
+  <strong>bibble</strong>
+<% end %>
+ERB
+  end
+
+  def test_case_when_parsing
+    assert_equal(<<HAML.rstrip, render_erb(<<ERB))
+- case foo.bar
+- when "bip"
+  %p bip
+- when "bop"
+  %p BOP
+- when bizzle.bang.boop.blip
+  %em BIZZLE BANG BOOP BLIP
+HAML
+<% case foo.bar %>
+<% when "bip" %>
+  <p>bip</p>
+<% when "bop" %>
+  <p>BOP</p>
+<% when bizzle.bang.boop.blip %>
+  <em>BIZZLE BANG BOOP BLIP</em>
+<% end %>
+ERB
+
+    assert_equal(<<HAML.rstrip, render_erb(<<ERB))
+- case foo.bar
+- when "bip"
+  %p bip
+- when "bop"
+  %p BOP
+- when bizzle.bang.boop.blip
+  %em BIZZLE BANG BOOP BLIP
+HAML
+<% case foo.bar
+   when "bip" %>
+  <p>bip</p>
+<% when "bop" %>
+  <p>BOP</p>
+<% when bizzle.bang.boop.blip %>
+  <em>BIZZLE BANG BOOP BLIP</em>
+<% end %>
+ERB
+  end
+
+  def test_begin_rescue_ensure
+    assert_equal(<<HAML.rstrip, render_erb(<<ERB))
+- begin
+  %p a
+- rescue FooException => e
+  %p b
+- ensure
+  %p c
+HAML
+<% begin %>
+  <p>a</p>
+<% rescue FooException => e %>
+  <p>b</p>
+<% ensure %>
+  <p>c</p>
+<% end %>
+ERB
+  end
+
+  # Regression
+
+  def test_tag_inside_block
+    assert_equal(<<HAML.rstrip, render_erb(<<ERB))
+%table
+  - foo.each do
+    %tr
+HAML
+<table>
+  <% foo.each do %>
+    <tr></tr>
+  <% end %>
+</table>
+ERB
+  end
+
+  def test_silent_inside_block_inside_tag
+    assert_equal(<<HAML.rstrip, render_erb(<<ERB))
+%table
+  - foo.each do
+    - haml_puts "foo"
+HAML
+<table>
+  <% foo.each do %>
+    <% haml_puts "foo" %>
+  <% end %>
+</table>
+ERB
+  end
+
+  def test_commented_erb_should_not_cause_indentation
+    assert_equal(<<HAML.rstrip, render_erb(<<ERB))
+%title
+  html2haml and multiline titles
+= # stylesheet_link_tag :first
+= stylesheet_link_tag 'another file'
+HAML
+<title>
+  html2haml and multiline titles
+</title>
+<%=# stylesheet_link_tag :first %>
+<%#= stylesheet_link_tag :second %>
+<%# stylesheet_link_tag :third %>
+<%= stylesheet_link_tag 'another file' %>
+ERB
+  end
+
+  def test_should_wrap_in_silent
+    assert_equal(<<HTML.rstrip, Haml::HTML::ERB.new(<<ERB).src)
+<haml:silent> some_variable_or_function \n</haml:silent>
+HTML
+<% some_variable_or_function %>
+ERB
+  end
+
+  #comment content is removed by erubis
+  def test_should_wrap_process_comments_as_empty_lines
+    assert_equal(<<HTML.rstrip, Haml::HTML::ERB.new(<<ERB).src)
+<haml:silent>\n</haml:silent>
+HTML
+<%# some_variable_or_function %>
+ERB
+  end
+
+end