haml-edge 2.3.55 → 2.3.56

data/EDGE_GEM_VERSION

@@ -1 +1 @@
-2.3.55
+2.3.56

data/VERSION

@@ -1 +1 @@
-2.3.55
+2.3.56

data/lib/haml/exec.rb

@@ -387,12 +387,20 @@ Description: Transforms an HTML file into corresponding Haml code.
 Options:
 END
 
-        opts.on('-r', '--rhtml', 'Parse RHTML tags.') do
-          @module_opts[:rhtml] = true
+        opts.on('-e', '--erb', 'Parse ERb tags.') do
+          @module_opts[:erb] = true
         end
 
-        opts.on('--no-rhtml', "Don't parse RHTML tags.") do
-          @options[:no_rhtml] = true
+        opts.on('--no-erb', "Don't parse ERb tags.") do
+          @options[:no_erb] = true
+        end
+
+        opts.on('-r', '--rhtml', 'Deprecated; same as --erb.') do
+          @module_opts[:erb] = true
+        end
+
+        opts.on('--no-rhtml', "Deprecated; same as --no-erb.") do
+          @options[:no_erb] = true
         end
 
         opts.on('-x', '--xhtml', 'Parse the input using the more strict XHTML parser.') do
@@ -410,8 +418,8 @@ END
         input = @options[:input]
         output = @options[:output]
 
-        @module_opts[:rhtml] ||= input.respond_to?(:path) && input.path =~ /\.(rhtml|erb)$/
-        @module_opts[:rhtml] &&= @options[:no_rhtml] != false
+        @module_opts[:erb] ||= input.respond_to?(:path) && input.path =~ /\.(rhtml|erb)$/
+        @module_opts[:erb] &&= @options[:no_erb] != false
 
         output.write(::Haml::HTML.new(input, @module_opts).render)
       rescue ::Haml::Error => e

data/lib/haml/filters.rb

@@ -271,7 +271,7 @@ END
       end
     end
 
-    # Parses the filtered text with ERB, like an RHTML template.
+    # Parses the filtered text with ERB.
     # Not available if the {file:HAML_REFERENCE.md#suppress_eval-option `:suppress_eval`} option is set to true.
     # Embedded Ruby code is evaluated in the same context as the Haml template.
     module ERB

data/lib/haml/html/erb.rb

@@ -0,0 +1,71 @@
+require 'cgi'
+require 'erubis'
+require 'ruby_parser'
+
+module Haml
+  class HTML
+    class ERB < Erubis::Basic::Engine
+      def self.compile(template)
+        new(template).src
+      end
+
+      def escaped_expr(code)
+        raise "html2haml doesn't support escaped expressions."
+      end
+
+      def add_preamble(src); end
+      def add_postamble(src); end
+
+      def add_text(src, text)
+        src << text
+      end
+
+      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
+
+      def add_expr_literal(src, code)
+        src << '<haml:loud>' << h(code) << '</haml:loud>'
+        src << '<haml:block>' if block_opener?(code)
+      end
+
+      def add_expr_debug(src, code)
+        raise "html2haml doesn't support debugging expressions."
+      end
+
+      private
+
+      def h(code)
+        CGI.escapeHTML(code)
+      end
+
+      # Returns whether the code is valid Ruby code on its own
+      def valid_ruby?(code)
+        RubyParser.new.parse(code)
+      rescue Racc::ParseError => e
+        false
+      end
+
+      # Checks if the Ruby code opens a block
+      def block_opener?(code)
+        valid_ruby?(code + "\nend") ||
+          valid_ruby?(code + "\nwhen foo\nend")
+      end
+
+      # Checks if the Ruby code closes a block
+      def block_closer?(code)
+        valid_ruby?("begin\n" + code)
+      end
+
+      # Checks if the Ruby code comes in the middle of a block
+      def mid_block?(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/haml/html.rb

@@ -9,33 +9,71 @@ module Haml
     # A module containing utility methods that every Hpricot node
     # should have.
     module Node
+      # Whether this node has already been converted to Haml.
+      # Only used for text nodes and elements.
+      #
+      # @return [Boolean]
+      attr_accessor :converted_to_haml
+
       # Returns the Haml representation of the given node.
       #
       # @param tabs [Fixnum] The indentation level of the resulting Haml.
       # @option options (see Haml::HTML#initialize)
       def to_haml(tabs, options)
-        parse_text(self.to_s, tabs)
+        return "" if converted_to_haml || to_s.strip.empty?
+        text = uninterp(self.to_s)
+        node = next_node
+        while node.is_a?(::Hpricot::Elem) && node.name == "haml:loud"
+          node.converted_to_haml = true
+          text << '#{' <<
+            CGI.unescapeHTML(node.inner_text).gsub(/\n\s*/, ' ').strip << '}'
+
+          if node.next_node.is_a?(::Hpricot::Text)
+            node = node.next_node
+            text << uninterp(node.to_s)
+            node.converted_to_haml = true
+          end
+
+          node = node.next_node
+        end
+        return parse_text_with_interpolation(text, tabs)
       end
 
       private
 
+      def erb_to_interpolation(text, options)
+        return text unless options[:erb]
+        text = CGI.escapeHTML(uninterp(text))
+        %w[<haml:loud> </haml:loud>].each {|str| text.gsub!(CGI.escapeHTML(str), str)}
+        ::Hpricot::XML(text).children.inject("") do |str, elem|
+          if elem.is_a?(::Hpricot::Text)
+            str + CGI.unescapeHTML(elem.to_s)
+          else # <haml:loud> element
+            str + '#{' + CGI.unescapeHTML(elem.innerText.strip) + '}'
+          end
+        end
+      end
+
       def tabulate(tabs)
         '  ' * tabs
       end
 
+      def uninterp(text)
+        text.gsub('#{', '\#{') #'
+      end
+
       def parse_text(text, tabs)
+        parse_text_with_interpolation(uninterp(text), tabs)
+      end
+
+      def parse_text_with_interpolation(text, tabs)
         text.strip!
-        text.gsub!('#{', '\#{') #'
-        if text.empty?
-          String.new
-        else
-          lines = text.split("\n")
+        return "" if text.empty?
 
-          lines.map do |line|
-            line.strip!
-            "#{tabulate(tabs)}#{'\\' if Haml::Engine::SPECIAL_CHARACTERS.include?(line[0])}#{line}\n"
-          end.join
-        end
+        text.split("\n").map do |line|
+          line.strip!
+          "#{tabulate(tabs)}#{'\\' if Haml::Engine::SPECIAL_CHARACTERS.include?(line[0])}#{line}\n"
+        end.join
       end
     end
   end
@@ -67,7 +105,7 @@ module Haml
   #       #=> "%a{:href => 'http://google.com'} Blat"
   class HTML
     # @param template [String, Hpricot::Node] The HTML template to convert
-    # @option options :rhtml [Boolean] (false) Whether or not to parse
+    # @option options :erb [Boolean] (false) Whether or not to parse
     #   ERB's `<%= %>` and `<% %>` into Haml's `=` and `-`
     # @option options :xhtml [Boolean] (false) Whether or not to parse
     #   the HTML strictly as XHTML
@@ -83,9 +121,9 @@ module Haml
 
         Haml::Util.check_encoding(template) {|msg, line| raise Haml::Error.new(msg, line)}
 
-        if @options[:rhtml]
-          match_to_html(template, /<%=(.*?)-?%>/m, 'loud')
-          match_to_html(template, /<%-?(.*?)-?%>/m,  'silent')
+        if @options[:erb]
+          require 'haml/html/erb'
+          template = ERB.compile(template)
         end
 
         method = @options[:xhtml] ? Hpricot.method(:XML) : method(:Hpricot)
@@ -122,7 +160,9 @@ module Haml
     class ::Hpricot::CData
       # @see Haml::HTML::Node#to_haml
       def to_haml(tabs, options)
-        "#{tabulate(tabs)}:cdata\n#{parse_text(self.content, tabs + 1)}"
+        content = parse_text_with_interpolation(
+          erb_to_interpolation(self.content, options), tabs + 1)
+        "#{tabulate(tabs)}:cdata\n#{content}"
       end
     end
 
@@ -161,7 +201,17 @@ module Haml
     class ::Hpricot::Comment
       # @see Haml::HTML::Node#to_haml
       def to_haml(tabs, options)
-        "#{tabulate(tabs)}/\n#{parse_text(self.content, tabs + 1)}"
+        content = self.content
+        if content =~ /\A(\[[^\]]+\])>(.*)<!\[endif\]\z/m
+          condition = $1
+          content = $2
+        end
+
+        if content.include?("\n")
+          "#{tabulate(tabs)}/#{condition}\n#{parse_text(content, tabs + 1)}"
+        else
+          "#{tabulate(tabs)}/#{condition} #{content.strip}"
+        end
       end
     end
 
@@ -169,32 +219,78 @@ module Haml
     class ::Hpricot::Elem
       # @see Haml::HTML::Node#to_haml
       def to_haml(tabs, options)
-        output = "#{tabulate(tabs)}"
-        if options[:rhtml] && name[0...5] == 'haml:'
-          return output + send("haml_tag_#{name[5..-1]}", CGI.unescapeHTML(self.inner_text))
+        return "" if converted_to_haml
+        if name == "script" &&
+            (attributes['type'].nil? || attributes['type'] == "text/javascript") &&
+            (attributes.keys - ['type']).empty?
+          return script_to_haml(tabs, options)
+        end
+
+        output = tabulate(tabs)
+        if options[:erb] && name[0...5] == 'haml:'
+          case name[5..-1]
+          when "loud"
+            return output + "= #{CGI.unescapeHTML(inner_text).gsub(/\n\s*/, ' ').strip}\n"
+          when "silent"
+            return CGI.unescapeHTML(inner_text).split("\n").map do |line|
+              next "" if line.strip.empty?
+              "#{output}- #{line.strip}\n"
+            end.join
+          when "block"
+            return render_children("", tabs, options)
+          end
         end
 
-        output += "%#{name}" unless name == 'div' &&
-          (static_id?(options) || static_classname?(options))
+        output << "%#{name}" unless name == 'div' &&
+          (static_id?(options) ||
+           static_classname?(options) &&
+           attributes['class'].split(' ').any?(&method(:haml_css_attr?)))
 
         if attributes
           if static_id?(options)
-            output += "##{attributes['id']}"
+            output << "##{attributes['id']}"
             remove_attribute('id')
           end
           if static_classname?(options)
-            attributes['class'].split(' ').each { |c| output += ".#{c}" }
+            leftover = attributes['class'].split(' ').reject do |c|
+              next unless haml_css_attr?(c)
+              output << ".#{c}"
+            end
             remove_attribute('class')
+            set_attribute('class', leftover.join(' ')) unless leftover.empty?
           end
-          output += haml_attributes(options) if attributes.length > 0
+          output << haml_attributes(options) if attributes.length > 0
         end
 
-        (self.children || []).inject(output + "\n") do |output, child|
-          output + child.to_haml(tabs + 1, options)
+        output << "/" if empty? && !etag
+
+        if children && children.size == 1
+          child = children.first
+          if child.is_a?(::Hpricot::Text)
+            if !child.to_s.include?("\n")
+              text = child.to_haml(tabs + 1, options)
+              return output + " " + text.lstrip unless text.chomp.include?("\n")
+              return output + "\n" + text
+            elsif ["pre", "textarea"].include?(name) ||
+                (name == "code" && parent.is_a?(::Hpricot::Elem) && parent.name == "pre")
+              return output + "\n#{tabulate(tabs + 1)}:preserve\n" +
+                innerText.gsub(/^/, tabulate(tabs + 2))
+            end
+          elsif child.is_a?(::Hpricot::Elem) && child.name == "haml:loud"
+            return output + child.to_haml(tabs + 1, options).lstrip
+          end
         end
+
+        render_children(output + "\n", tabs, options)
       end
 
       private
+
+      def render_children(so_far, tabs, options)
+        (self.children || []).inject(so_far) do |output, child|
+          output + child.to_haml(tabs + 1, options)
+        end
+      end
       
       def dynamic_attributes
         @dynamic_attributes ||= begin
@@ -211,47 +307,53 @@ module Haml
         end
       end
 
-      def haml_tag_loud(text)
-        "= #{text.gsub(/\n\s*/, ' ').strip}\n"
-      end
+      def script_to_haml(tabs, options)
+        content =
+          if children.first.is_a?(::Hpricot::CData)
+            children.first.content
+          else
+            CGI.unescapeHTML(self.innerText)
+          end
+          
+        content = erb_to_interpolation(content, options)
+        content.gsub!(/\A\s*\n(\s*)/, '\1')
+        original_indent = content[/\A(\s*)/, 1]
+        if content.split("\n").all? {|l| l.strip.empty? || l =~ /^#{original_indent}/}
+          content.gsub!(/^#{original_indent}/, tabulate(tabs + 1))
+        end
 
-      def haml_tag_silent(text)
-        text.split("\n").map { |line| "- #{line.strip}\n" }.join
+        "#{tabulate(tabs)}:javascript\n#{content}"
       end
 
       def static_attribute?(name, options)
-        attributes[name] and !dynamic_attribute?(name, options)
+        attributes[name] && !dynamic_attribute?(name, options)
       end
       
       def dynamic_attribute?(name, options)
-        options[:rhtml] and dynamic_attributes.key?(name)
+        options[:erb] and dynamic_attributes.key?(name)
       end
       
       def static_id?(options)
-        static_attribute?('id', options)
+        static_attribute?('id', options) && haml_css_attr?(attributes['id'])
       end
       
       def static_classname?(options)
         static_attribute?('class', options)
       end
 
+      def haml_css_attr?(attr)
+        attr =~ /^[-:\w]+$/
+      end
+
       # Returns a string representation of an attributes hash
       # that's prettier than that produced by Hash#inspect
       def haml_attributes(options)
-        attrs = attributes.map do |name, value|
+        attrs = attributes.sort.map do |name, value|
           value = dynamic_attribute?(name, options) ? dynamic_attributes[name] : value.inspect
           name = name.index(/\W/) ? name.inspect : ":#{name}"
           "#{name} => #{value}"
         end
-        "{ #{attrs.join(', ')} }"
-      end
-    end
-
-    private
-
-    def match_to_html(string, regex, tag)
-      string.gsub!(regex) do
-        "<haml:#{tag}>#{CGI.escapeHTML($1)}</haml:#{tag}>"
+        "{#{attrs.join(', ')}}"
       end
     end
   end

data/test/benchmark.rb

@@ -40,7 +40,7 @@ RBench.run(times) do
   template_name = 'standard'
   directory = File.dirname(__FILE__) + '/haml'
   haml_template    = File.read("#{directory}/templates/#{template_name}.haml")
-  erb_template     = File.read("#{directory}/rhtml/#{template_name}.rhtml")
+  erb_template     = File.read("#{directory}/erb/#{template_name}.erb")
   markaby_template = File.read("#{directory}/markaby/#{template_name}.mab")
 
   report "Cached" do
@@ -64,10 +64,10 @@ RBench.run(times) do
     Haml::Template.options[:ugly] = false
     # To cache the template
     render @base, 'haml/templates/standard'
-    render @base, 'haml/rhtml/standard'
+    render @base, 'haml/erb/standard'
 
     haml { render @base, 'haml/templates/standard' }
-    erb  { render @base, 'haml/rhtml/standard' }
+    erb  { render @base, 'haml/erb/standard' }
 
     Haml::Template.options[:ugly] = true
     render @base, 'haml/templates/standard_ugly'
@@ -81,10 +81,10 @@ RBench.run(times) do
     Haml::Template.options[:ugly] = false
     # To cache the template
     render @base, 'haml/templates/action_view'
-    render @base, 'haml/rhtml/action_view'
+    render @base, 'haml/erb/action_view'
 
     haml { render @base, 'haml/templates/action_view' }
-    erb  { render @base, 'haml/rhtml/action_view' }
+    erb  { render @base, 'haml/erb/action_view' }
 
     Haml::Template.options[:ugly] = true
     render @base, 'haml/templates/action_view_ugly'

data/test/haml/{rhtml/_av_partial_1.rhtml → erb/_av_partial_1.erb}

@@ -6,7 +6,7 @@
       <li>
         <strong>Partial:</strong>
         <% @nesting = 5 %>
-        <%= render :partial => 'haml/rhtml/av_partial_2' %>
+        <%= render :partial => 'haml/erb/av_partial_2' %>
     <% end %>
   </ul>
 </div>

data/test/haml/{rhtml/_av_partial_2.rhtml → erb/_av_partial_2.erb}

@@ -3,6 +3,6 @@
   <h3>This is a crazy deep-nested partial.</h3>
   <p>Nesting level <%= @nesting %></p>
   <% if @nesting > 0 %>
-    <%= render :partial => 'haml/rhtml/av_partial_2' %>
+    <%= render :partial => 'haml/erb/av_partial_2' %>
   <% end %>
 </div>

data/test/haml/html2haml_test.rb

@@ -3,7 +3,6 @@ require File.dirname(__FILE__) + '/../test_helper'
 require 'haml/html'
 
 class Html2HamlTest < Test::Unit::TestCase
-
   def test_empty_render_should_remain_empty
     assert_equal '', render('')
   end
@@ -22,14 +21,21 @@ class Html2HamlTest < Test::Unit::TestCase
   end
 
   def test_should_have_pretty_attributes
-    assert_equal_attributes('%input{ :type => "text", :name => "login" }',
+    assert_equal('%input{:name => "login", :type => "text"}/',
       render('<input type="text" name="login" />'))
-    assert_equal_attributes('%meta{ "http-equiv" => "Content-Type", :content => "text/html" }',
+    assert_equal('%meta{:content => "text/html", "http-equiv" => "Content-Type"}/',
       render('<meta http-equiv="Content-Type" content="text/html" />'))
   end
 
-  def test_sqml_comment
-    assert_equal "/\n  IE sucks", render('<!-- IE sucks -->')
+  def test_class_with_dot_and_hash
+    assert_equal('%div{:class => "foo.bar"}', render("<div class='foo.bar'></div>"))
+    assert_equal('%div{:class => "foo#bar"}', render("<div class='foo#bar'></div>"))
+    assert_equal('.foo.bar{:class => "foo#bar foo.bar"}', render("<div class='foo foo#bar bar foo.bar'></div>"))
+  end
+
+  def test_id_with_dot_and_hash
+    assert_equal('%div{:id => "foo.bar"}', render("<div id='foo.bar'></div>"))
+    assert_equal('%div{:id => "foo#bar"}', render("<div id='foo#bar'></div>"))
   end
 
   def test_interpolation
@@ -37,54 +43,7 @@ class Html2HamlTest < Test::Unit::TestCase
   end
 
   def test_interpolation_in_attrs
-    assert_equal('%p{ :foo => "\#{bar} baz" }', render('<p foo="#{bar} baz"></p>'))
-  end
-
-  def test_rhtml
-    assert_equal '- foo = bar', render_rhtml('<% foo = bar %>')
-    assert_equal '- foo = bar', render_rhtml('<% foo = bar -%>')
-    assert_equal '= h @item.title', render_rhtml('<%=h @item.title %>')
-    assert_equal '= h @item.title', render_rhtml('<%=h @item.title -%>')
-  end
-  
-  def test_rhtml_with_html_special_chars
-    assert_equal '= 3 < 5 ? "OK" : "Your computer is b0rken"',
-      render_rhtml(%Q{<%= 3 < 5 ? "OK" : "Your computer is b0rken" %>})
-  end
-  
-  def test_rhtml_in_class_attribute
-    assert_equal "%div{ :class => dyna_class }\n  I have a dynamic attribute",
-      render_rhtml(%Q{<div class="<%= dyna_class %>">I have a dynamic attribute</div>})
-  end
-  
-  def test_rhtml_in_id_attribute
-    assert_equal "%div{ :id => dyna_id }\n  I have a dynamic attribute",
-      render_rhtml(%Q{<div id="<%= dyna_id %>">I have a dynamic attribute</div>})
-  end
-  
-  def test_rhtml_in_attribute_results_in_string_interpolation
-    assert_equal %(%div{ :id => "item_\#{i}" }\n  Ruby string interpolation FTW),
-      render_rhtml(%Q{<div id="item_<%= i %>">Ruby string interpolation FTW</div>})
-  end
-  
-  def test_rhtml_in_attribute_with_trailing_content
-    assert_equal %(%div{ :class => "\#{12}!" }\n  Bang!),
-      render_rhtml(%Q{<div class="<%= 12 %>!">Bang!</div>})
-  end
-  
-  def test_rhtml_in_html_escaped_attribute
-    assert_equal %(%div{ :class => "foo" }\n  Bang!),
-      render_rhtml(%Q{<div class="<%= "foo" %>">Bang!</div>})
-  end
-  
-  def test_rhtml_in_attribute_to_multiple_interpolations
-    assert_equal %(%div{ :class => "\#{12} + \#{13}" }\n  Math is super),
-      render_rhtml(%Q{<div class="<%= 12 %> + <%= 13 %>">Math is super</div>})
-  end
-  
-  def test_whitespace_eating_erb_tags
-    assert_equal %(- form_for),
-      render_rhtml(%Q{<%- form_for -%>})
+    assert_equal('%p{:foo => "\#{bar} baz"}', render('<p foo="#{bar} baz"></p>'))
   end
 
   def test_cdata
@@ -103,13 +62,443 @@ HAML
 HTML
   end
 
-  def test_interpolation_in_rhtml
-    assert_equal('= "Foo #{bar} baz"', render_rhtml('<%= "Foo #{bar} baz" %>'))
+  def test_self_closing_tag
+    assert_equal("%foo/", render("<foo />"))
+  end
+
+  def test_inline_text
+    assert_equal("%p foo", render("<p>foo</p>"))
+  end
+
+  def test_inline_comment
+    assert_equal("/ foo", render("<!-- foo -->"))
+  end
+
+  def test_non_inline_comment
+    assert_equal(<<HAML.rstrip, render(<<HTML))
+/
+  Foo
+  Bar
+HAML
+<!-- Foo
+Bar -->
+HTML
+  end
+
+  def test_non_inline_text
+    assert_equal(<<HAML.rstrip, render(<<HTML))
+%p
+  foo
+HAML
+<p>
+  foo
+</p>
+HTML
+    assert_equal(<<HAML.rstrip, render(<<HTML))
+%p
+  foo
+HAML
+<p>
+  foo</p>
+HTML
+    assert_equal(<<HAML.rstrip, render(<<HTML))
+%p
+  foo
+HAML
+<p>foo
+</p>
+HTML
+  end
+
+  def test_script_tag
+    assert_equal(<<HAML.rstrip, render(<<HTML))
+:javascript
+  function foo() {
+      return "12" & "13";
+  }
+HAML
+<script type="text/javascript">
+    function foo() {
+        return "12" &amp; "13";
+    }
+</script>
+HTML
+  end
+
+  def test_script_tag_with_cdata
+    assert_equal(<<HAML.rstrip, render(<<HTML))
+:javascript
+  function foo() {
+    return "&amp;";
+  }
+HAML
+<script type="text/javascript">
+  <![CDATA[
+    function foo() {
+      return "&amp;";
+    }
+  ]]>
+</script>
+HTML
+  end
+
+  def test_pre
+    assert_equal(<<HAML.rstrip, render(<<HTML))
+%pre
+  :preserve
+    foo
+      bar
+    baz
+HAML
+<pre>foo
+  bar
+baz</pre>
+HTML
+  end
+
+  def test_pre_code
+    assert_equal(<<HAML.rstrip, render(<<HTML))
+%pre
+  %code
+    :preserve
+      foo
+        bar
+      baz
+HAML
+<pre><code>foo
+  bar
+baz</code></pre>
+HTML
+  end
+
+  def test_code_without_pre
+    assert_equal(<<HAML.rstrip, render(<<HTML))
+%code
+  foo
+  bar
+  baz
+HAML
+<code>foo
+  bar
+baz</code>
+HTML
+  end
+
+  def test_conditional_comment
+    assert_equal(<<HAML.rstrip, render(<<HTML))
+/[if foo]
+  bar
+  baz
+HAML
+<!--[if foo]>
+  bar
+  baz
+<![endif]-->
+HTML
+  end
+
+  def test_inline_conditional_comment
+    assert_equal(<<HAML.rstrip, render(<<HTML))
+/[if foo] bar baz
+HAML
+<!--[if foo]> bar baz <![endif]-->
+HTML
+  end
+
+  ## ERB
+
+  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_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_interpolation_in_rhtml_attrs
-    assert_equal('%p{ :foo => "#{bar} baz" }',
-      render_rhtml('<p foo="<%= "#{bar} baz" %>"></p>'))
+  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
+
+  ### 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
 
   # Encodings
@@ -140,13 +529,7 @@ HTML
     Haml::HTML.new(text, options).render.rstrip
   end
 
-  def render_rhtml(text)
-    render(text, :rhtml => true)
-  end
-
-  def assert_equal_attributes(expected, result)
-    expected_attr, result_attr = [expected, result].map { |s| s.gsub!(/\{ (.+) \}/, ''); $1.split(', ').sort }
-    assert_equal expected_attr, result_attr
-    assert_equal expected, result
+  def render_erb(text)
+    render(text, :erb => true)
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: haml-edge
 version: !ruby/object:Gem::Version 
-  version: 2.3.55
+  version: 2.3.56
 platform: ruby
 authors: 
 - Nathan Weizenbaum
@@ -73,6 +73,8 @@ files:
 - lib/haml/template/plugin.rb
 - lib/haml/util.rb
 - lib/haml/version.rb
+- lib/haml/html
+- lib/haml/html/erb.rb
 - lib/sass.rb
 - lib/sass
 - lib/sass/css.rb
@@ -148,10 +150,6 @@ files:
 - test/haml/results/very_basic.xhtml
 - test/haml/results/whitespace_handling.xhtml
 - test/haml/rhtml
-- test/haml/rhtml/_av_partial_1.rhtml
-- test/haml/rhtml/_av_partial_2.rhtml
-- test/haml/rhtml/action_view.rhtml
-- test/haml/rhtml/standard.rhtml
 - test/haml/spec
 - test/haml/spec_test.rb
 - test/haml/template_test.rb
@@ -188,6 +186,11 @@ files:
 - test/haml/templates/very_basic.haml
 - test/haml/templates/whitespace_handling.haml
 - test/haml/util_test.rb
+- test/haml/erb
+- test/haml/erb/_av_partial_1.erb
+- test/haml/erb/_av_partial_2.erb
+- test/haml/erb/action_view.erb
+- test/haml/erb/standard.rhtml
 - test/linked_rails.rb
 - test/sass
 - test/sass/css2sass_test.rb