haml 4.0.7 → 5.0.0

data/test/helper_test.rb

@@ -1,32 +1,13 @@
 require 'test_helper'
+require "active_model/naming"
 
-class ActionView::Base
-  def nested_tag
-    content_tag(:span) {content_tag(:div) {"something"}}
-  end
-
-  def wacky_form
-    form_tag("/foo") {"bar"}
-  end
+class FormModel
+  extend ActiveModel::Naming
 end
 
-module Haml::Helpers
-  def something_that_uses_haml_concat
-    haml_concat('foo').to_s
-  end
-
-  def render_something_with_haml_concat
-    haml_concat "<p>"
-  end
-
-  def render_something_with_haml_tag_and_concat
-    haml_tag 'p' do
-      haml_concat '<foo>'
-    end
-  end
-end
+class HelperTest < Haml::TestCase
+  TEXT_AREA_CONTENT_REGEX = /<(textarea)[^>]*>\n(.*?)<\/\1>/im
 
-class HelperTest < MiniTest::Unit::TestCase
   Post = Struct.new('Post', :body, :error_field, :errors)
   class PostErrors
     def on(name)
@@ -41,16 +22,18 @@ class HelperTest < MiniTest::Unit::TestCase
   end
 
   def setup
-    @base = ActionView::Base.new
+    @base = Class.new(ActionView::Base) {
+      def nested_tag
+        content_tag(:span) {content_tag(:div) {"something"}}
+      end
+
+      def wacky_form
+        form_tag("/foo") {"bar"}
+      end
+    }.new
     @base.controller = ActionController::Base.new
     @base.view_paths << File.expand_path("../templates", __FILE__)
-
-    if defined?(ActionController::Response)
-      # This is needed for >=3.0.0
-      @base.controller.response = ActionController::Response.new
-    end
-
-    @base.instance_variable_set('@post', Post.new("Foo bar\nbaz", nil, PostErrors.new))
+    @base.instance_variable_set(:@post, Post.new("Foo bar\nbaz", nil, PostErrors.new))
   end
 
   def render(text, options = {})
@@ -59,12 +42,29 @@ class HelperTest < MiniTest::Unit::TestCase
   end
 
   def test_rendering_with_escapes
+    def @base.render_something_with_haml_concat
+      haml_concat "<p>"
+    end
+    def @base.render_something_with_haml_tag_and_concat
+      haml_tag 'p' do
+        haml_concat '<foo>'
+      end
+    end
+
     output = render(<<-HAML, :action_view)
 - render_something_with_haml_concat
 - render_something_with_haml_tag_and_concat
 - render_something_with_haml_concat
 HAML
-    assert_equal("&lt;p&gt;\n<p>\n  <foo>\n</p>\n&lt;p&gt;\n", output)
+    assert_equal("&lt;p&gt;\n<p>\n  &lt;foo&gt;\n</p>\n&lt;p&gt;\n", output)
+  end
+
+  def test_with_raw_haml_concat
+    haml = <<HAML
+- with_raw_haml_concat do
+  - haml_concat "<>&"
+HAML
+    assert_equal("<>&\n", render(haml, :action_view))
   end
 
   def test_flatten
@@ -79,13 +79,13 @@ HAML
   end
 
   def test_list_of_should_render_correctly
-    assert_equal("<li>1</li>\n<li>2</li>\n", render("= list_of([1, 2]) do |i|\n  = i"))
-    assert_equal("<li>[1]</li>\n", render("= list_of([[1]]) do |i|\n  = i.inspect"))
-    assert_equal("<li>\n  <h1>Fee</h1>\n  <p>A word!</p>\n</li>\n<li>\n  <h1>Fi</h1>\n  <p>A word!</p>\n</li>\n<li>\n  <h1>Fo</h1>\n  <p>A word!</p>\n</li>\n<li>\n  <h1>Fum</h1>\n  <p>A word!</p>\n</li>\n",
+    assert_equal("<li>1</li>\n<li>2</li>", render("= list_of([1, 2]) do |i|\n  = i"))
+    assert_equal("<li>[1]</li>", render("= list_of([[1]]) do |i|\n  = i.inspect"))
+    assert_equal("<li>\n  <h1>Fee</h1>\n  <p>A word!</p>\n</li>\n<li>\n  <h1>Fi</h1>\n  <p>A word!</p>\n</li>\n<li>\n  <h1>Fo</h1>\n  <p>A word!</p>\n</li>\n<li>\n  <h1>Fum</h1>\n  <p>A word!</p>\n</li>",
       render("= list_of(['Fee', 'Fi', 'Fo', 'Fum']) do |title|\n  %h1= title\n  %p A word!"))
-    assert_equal("<li c='3'>1</li>\n<li c='3'>2</li>\n", render("= list_of([1, 2], {:c => 3}) do |i|\n  = i"))
-    assert_equal("<li c='3'>[1]</li>\n", render("= list_of([[1]], {:c => 3}) do |i|\n  = i.inspect"))
-    assert_equal("<li c='3'>\n  <h1>Fee</h1>\n  <p>A word!</p>\n</li>\n<li c='3'>\n  <h1>Fi</h1>\n  <p>A word!</p>\n</li>\n<li c='3'>\n  <h1>Fo</h1>\n  <p>A word!</p>\n</li>\n<li c='3'>\n  <h1>Fum</h1>\n  <p>A word!</p>\n</li>\n",
+    assert_equal("<li c='3'>1</li>\n<li c='3'>2</li>", render("= list_of([1, 2], {:c => 3}) do |i|\n  = i"))
+    assert_equal("<li c='3'>[1]</li>", render("= list_of([[1]], {:c => 3}) do |i|\n  = i.inspect"))
+    assert_equal("<li c='3'>\n  <h1>Fee</h1>\n  <p>A word!</p>\n</li>\n<li c='3'>\n  <h1>Fi</h1>\n  <p>A word!</p>\n</li>\n<li c='3'>\n  <h1>Fo</h1>\n  <p>A word!</p>\n</li>\n<li c='3'>\n  <h1>Fum</h1>\n  <p>A word!</p>\n</li>",
       render("= list_of(['Fee', 'Fi', 'Fo', 'Fum'], {:c => 3}) do |title|\n  %h1= title\n  %p A word!"))
   end
 
@@ -95,15 +95,15 @@ HAML
   end
 
   def test_tabs
-    assert_equal("foo\n  bar\nbaz\n", render("foo\n- tab_up\nbar\n- tab_down\nbaz"))
-    assert_equal("          <p>tabbed</p>\n", render("- buffer.tabulation=5\n%p tabbed"))
+    assert_equal("foo\nbar\nbaz\n", render("foo\n- tab_up\nbar\n- tab_down\nbaz"))
+    assert_equal("<p>tabbed</p>\n", render("- buffer.tabulation=5\n%p tabbed"))
   end
 
   def test_with_tabs
     assert_equal(<<HTML, render(<<HAML))
 Foo
-    Bar
-    Baz
+Bar
+Baz
 Baz
 HTML
 Foo
@@ -120,7 +120,7 @@ HAML
 
     begin
       ActionView::Base.new.render(:inline => "<%= flatten('Foo\\nBar') %>")
-    rescue NoMethodError, Haml::Util.av_template_class(:Error)
+    rescue NoMethodError, ActionView::Template::Error
       proper_behavior = true
     end
     assert(proper_behavior)
@@ -138,18 +138,26 @@ HAML
   end
 
   def test_form_tag
-    # This is usually provided by ActionController::Base.
     def @base.protect_against_forgery?; false; end
-
     rendered = render(<<HAML, :action_view)
 = form_tag 'foo' do
-  %p bar
-  %strong baz
+ %p bar
+ %strong baz
 HAML
-    fragment = Nokogiri::HTML.fragment(rendered)
-    assert_equal 'foo', fragment.css('form').first.attributes['action'].to_s
-    assert_equal 'bar', fragment.css('form p').first.text.strip
-    assert_equal 'baz', fragment.css('form strong').first.text.strip
+   fragment = Nokogiri::HTML.fragment(rendered)
+   assert_equal 'foo', fragment.css('form').first.attributes['action'].to_s
+   assert_equal 'bar', fragment.css('form p').first.text.strip
+   assert_equal 'baz', fragment.css('form strong').first.text.strip
+  end
+
+  def test_form_for
+    # FIXME: current HAML doesn't do proper indentation with form_for (it's the capture { output } in #form_for).
+    def @base.protect_against_forgery?; false; end
+    rendered = render(<<HAML, :action_view)
+= form_for OpenStruct.new, url: 'foo', as: :post do |f|
+  = f.text_field :name
+HAML
+    assert_match(/<(form|div)[^>]+><input/, rendered)
   end
 
   def test_pre
@@ -157,56 +165,40 @@ HAML
                  render('= content_tag "pre", "Foo bar\n   baz"', :action_view))
   end
 
-  # Rails >= 3.2.3 adds a newline after opening textarea tags.
-  def self.rails_text_area_helpers_emit_a_newline?
-    major, minor, tiny = ActionPack::VERSION::MAJOR, ActionPack::VERSION::MINOR, ActionPack::VERSION::TINY
-    major == 4 || ((major == 3) && (minor >= 2) && (tiny >= 3))
-  end
-
-  def text_area_content_regex
-    @text_area_content_regex ||= if self.class.rails_text_area_helpers_emit_a_newline?
-      /<(textarea)[^>]*>\n(.*?)<\/\1>/im
-    else
-      /<(textarea)[^>]*>(.*?)<\/\1>/im
-    end
-  end
-
   def test_text_area_tag
     output = render('= text_area_tag "body", "Foo\nBar\n Baz\n   Boom"', :action_view)
-    match_data = output.match(text_area_content_regex)
+    match_data = output.match(TEXT_AREA_CONTENT_REGEX)
     assert_equal "Foo&#x000A;Bar&#x000A; Baz&#x000A;   Boom", match_data[2]
   end
 
   def test_text_area
     output = render('= text_area :post, :body', :action_view)
-    match_data = output.match(text_area_content_regex)
+    match_data = output.match(TEXT_AREA_CONTENT_REGEX)
     assert_equal "Foo bar&#x000A;baz", match_data[2]
   end
 
   def test_partials_should_not_cause_textareas_to_be_indented
     # non-indentation of textareas rendered inside partials
-    @base.instance_variable_set('@post', Post.new("Foo", nil, PostErrors.new))
+    @base.instance_variable_set(:@post, Post.new("Foo", nil, PostErrors.new))
     output = render(".foo\n  .bar\n    = render '/text_area_helper'", :action_view)
-    match_data = output.match(text_area_content_regex)
+    match_data = output.match(TEXT_AREA_CONTENT_REGEX)
     assert_equal 'Foo', match_data[2]
   end
 
-  if rails_text_area_helpers_emit_a_newline?
-    def test_textareas_should_prerve_leading_whitespace
-      # leading whitespace preservation
-      @base.instance_variable_set('@post', Post.new("    Foo", nil, PostErrors.new))
-      output = render(".foo\n  = text_area :post, :body", :action_view)
-      match_data = output.match(text_area_content_regex)
-      assert_equal '&#x0020;   Foo', match_data[2]
-    end
+  def test_textareas_should_preserve_leading_whitespace
+    # leading whitespace preservation
+    @base.instance_variable_set(:@post, Post.new("    Foo", nil, PostErrors.new))
+    output = render(".foo\n  = text_area :post, :body", :action_view)
+    match_data = output.match(TEXT_AREA_CONTENT_REGEX)
+    assert_equal '&#x0020;   Foo', match_data[2]
+  end
 
-    def test_textareas_should_prerve_leading_whitespace_in_partials
-      # leading whitespace in textareas rendered inside partials
-      @base.instance_variable_set('@post', Post.new("    Foo", nil, PostErrors.new))
-      output = render(".foo\n  .bar\n    = render '/text_area_helper'", :action_view)
-      match_data = output.match(text_area_content_regex)
-      assert_equal '&#x0020;   Foo', match_data[2]
-    end
+  def test_textareas_should_preserve_leading_whitespace_in_partials
+    # leading whitespace in textareas rendered inside partials
+    @base.instance_variable_set(:@post, Post.new("    Foo", nil, PostErrors.new))
+    output = render(".foo\n  .bar\n    = render '/text_area_helper'", :action_view)
+    match_data = output.match(TEXT_AREA_CONTENT_REGEX)
+    assert_equal '&#x0020;   Foo', match_data[2]
   end
 
   def test_capture_haml
@@ -306,8 +298,12 @@ HAML
     assert_equal("<p id='foo&amp;bar'>baz</p>\n", render("%p{:id => 'foo&bar'} baz", :escape_html => true))
   end
 
-  def test_haml_tag_autoclosed_tags_are_closed
-    assert_equal("<br class='foo' />\n", render("- haml_tag :br, :class => 'foo'"))
+  def test_haml_tag_autoclosed_tags_are_closed_xhtml
+    assert_equal("<br class='foo' />\n", render("- haml_tag :br, :class => 'foo'", :format => :xhtml))
+  end
+
+  def test_haml_tag_autoclosed_tags_are_closed_html
+    assert_equal("<br class='foo'>\n", render("- haml_tag :br, :class => 'foo'", :format => :html5))
   end
 
   def test_haml_tag_with_class_array
@@ -338,7 +334,8 @@ HAML
   end
 
   def test_haml_tag_flags
-    assert_equal("<p />\n", render("- haml_tag :p, :/"))
+    assert_equal("<p />\n", render("- haml_tag :p, :/", :format => :xhtml))
+    assert_equal("<p>\n", render("- haml_tag :p, :/", :format => :html5))
     assert_equal("<p>kumquat</p>\n", render("- haml_tag :p, :< do\n  kumquat"))
 
     assert_raises(Haml::Error) { render("- haml_tag :p, 'foo', :/") }
@@ -361,12 +358,19 @@ HTML
 HAML
   end
 
+  def test_haml_concat_inside_haml_tag_escaped_with_xss
+    assert_equal("<p>\n  &lt;&gt;&amp;\n</p>\n", render(<<HAML, :action_view))
+- haml_tag :p do
+  - haml_concat "<>&"
+HAML
+  end
+
   def test_haml_concat_with_multiline_string
     assert_equal(<<HTML, render(<<HAML))
 <p>
-  foo
-  bar
-  baz
+foo
+bar
+baz
 </p>
 HTML
 %p
@@ -374,10 +378,10 @@ HTML
 HAML
   end
 
-  def test_haml_tag_with_ugly
-    assert_equal(<<HTML, render(<<HAML, :ugly => true))
+  def test_haml_tag
+    assert_equal(<<HTML, render(<<HAML))
 <p>
-<strong>Hi!</strong>
+  <strong>Hi!</strong>
 </p>
 HTML
 - haml_tag :p do
@@ -385,6 +389,41 @@ HTML
 HAML
   end
 
+  def test_haml_tag_if_positive
+    assert_equal(<<HTML, render(<<HAML))
+<div class='conditional'>
+<p>A para</p>
+</div>
+HTML
+- haml_tag_if true, '.conditional' do
+  %p A para
+HAML
+  end
+
+  def test_haml_tag_if_positive_with_attributes
+    assert_equal(<<HTML, render(<<HAML))
+<div class='conditional' foo='bar'>
+<p>A para</p>
+</div>
+HTML
+- haml_tag_if true, '.conditional',  {:foo => 'bar'} do
+  %p A para
+HAML
+  end
+
+  def test_haml_tag_if_negative
+    assert_equal(<<HTML, render(<<HAML))
+<p>A para</p>
+HTML
+- haml_tag_if false, '.conditional' do
+  %p A para
+HAML
+  end
+
+  def test_haml_tag_if_error_return
+    assert_raises(Haml::Error) { render("= haml_tag_if false, '.conditional' do\n  %p Hello") }
+  end
+
   def test_is_haml
     assert(!ActionView::Base.new.is_haml?)
     assert_equal("true\n", render("= is_haml?"))
@@ -406,15 +445,14 @@ HAML
   end
 
   def test_capture_deals_properly_with_collections
-    Haml::Helpers.module_eval do
-      def trc(collection, &block)
-        collection.each do |record|
-          haml_concat capture_haml(record, &block)
-        end
+    obj = Object.new
+    def obj.trc(collection, &block)
+      collection.each do |record|
+        haml_concat capture_haml(record, &block)
       end
     end
 
-    assert_equal("1\n\n2\n\n3\n\n", render("- trc([1, 2, 3]) do |i|\n  = i.inspect"))
+    assert_equal("1\n\n2\n\n3\n\n", render("- trc([1, 2, 3]) do |i|\n  = i.inspect", scope: obj))
   end
 
   def test_capture_with_string_block
@@ -422,17 +460,57 @@ HAML
   end
 
   def test_capture_with_non_string_value_reurns_nil
-    Haml::Helpers.module_eval do
-      def check_capture_returns_nil(&block)
-        contents = capture(&block)
+    def @base.check_capture_returns_nil(&block)
+      contents = capture(&block)
 
-        contents << "ERROR" if contents
-      end
+      contents << "ERROR" if contents
     end
 
     assert_equal("\n", render("= check_capture_returns_nil { 2 }", :action_view))
   end
 
+
+  class HomemadeViewContext
+    include ActionView::Context
+    include ActionView::Helpers::FormHelper
+
+    def initialize
+      _prepare_context
+    end
+
+    def url_for(*)
+      "/"
+    end
+
+    def dom_class(*)
+    end
+
+    def dom_id(*)
+    end
+
+    def m # I have to inject the model into the view using an instance method, using locals doesn't work.
+      FormModel.new
+    end
+
+    def protect_against_forgery?
+    end
+
+    # def capture(*args, &block)
+    #   capture_haml(*args, &block)
+    # end
+  end
+
+  def test_form_for_with_homemade_view_context
+    handler  = ActionView::Template.handler_for_extension("haml")
+    template = ActionView::Template.new(<<HAML, "inline template", handler, {})
+= form_for(m, :url => "/") do
+  %b Bold!
+HAML
+
+    # see if Bold is within form tags:
+    assert_match(/<form.*>.*<b>Bold!<\/b>.*<\/form>/m, template.render(HomemadeViewContext.new, {}))
+  end
+
   def test_find_and_preserve_with_block
     assert_equal("<pre>Foo&#x000A;Bar</pre>\nFoo\nBar\n",
                  render("= find_and_preserve do\n  %pre\n    Foo\n    Bar\n  Foo\n  Bar"))
@@ -444,7 +522,7 @@ HAML
   end
 
   def test_preserve_with_block
-    assert_equal("<pre>Foo&#x000A;Bar</pre>&#x000A;Foo&#x000A;Bar\n",
+    assert_equal("<pre>Foo&#x000A;Bar</pre>&#x000A;Foo&#x000A;Bar",
                  render("= preserve do\n  %pre\n    Foo\n    Bar\n  Foo\n  Bar"))
   end
 
@@ -481,17 +559,22 @@ MESSAGE
   end
 
   def test_error_return_line
-    render("%p foo\n= haml_concat 'foo'\n%p bar")
+    render("%p foo\n= haml_concat('foo').to_s\n%p bar")
     assert false, "Expected Haml::Error"
   rescue Haml::Error => e
-    assert_equal 2, e.backtrace[1].scan(/:(\d+)/).first.first.to_i
+    assert_equal 2, e.backtrace[0].scan(/:(\d+)/).first.first.to_i
   end
 
   def test_error_return_line_in_helper
-    render("- something_that_uses_haml_concat")
+    obj = Object.new
+    def obj.something_that_uses_haml_concat
+      haml_concat('foo').to_s
+    end
+
+    render("- something_that_uses_haml_concat", scope: obj)
     assert false, "Expected Haml::Error"
   rescue Haml::Error => e
-    assert_equal 15, e.backtrace[0].scan(/:(\d+)/).first.first.to_i
+    assert_equal __LINE__ - 6, e.backtrace[0].scan(/:(\d+)/).first.first.to_i
   end
 
   class ActsLikeTag
@@ -559,7 +642,7 @@ HAML
 
   def test_escape_once_leaves_numeric_references
     assert_equal "&quot;&gt;&lt;&amp; &#160;", Haml::Helpers.escape_once('"><& &#160;') #decimal
-    #assert_equal "&quot;&gt;&lt;&amp; &#x00a0;", Haml::Helpers.escape_once('"><& &#x00a0;') #hexadecimal
+    assert_equal "&quot;&gt;&lt;&amp; &#x00a0;", Haml::Helpers.escape_once('"><& &#x00a0;') #hexadecimal
   end
 
   def test_escape_once_encoding
@@ -571,6 +654,36 @@ HAML
     $stderr = old_stderr
   end
 
+  def test_html_attrs_xhtml
+    assert_equal("<html lang='en-US' xml:lang='en-US' xmlns='http://www.w3.org/1999/xhtml'></html>\n",
+                  render("%html{html_attrs}", :format => :xhtml))
+  end
+
+  def test_html_attrs_html4
+    assert_equal("<html lang='en-US'></html>\n",
+                  render("%html{html_attrs}", :format => :html4))
+  end
+
+  def test_html_attrs_html5
+    assert_equal("<html lang='en-US'></html>\n",
+                  render("%html{html_attrs}", :format => :html5))
+  end
+
+  def test_html_attrs_xhtml_other_lang
+    assert_equal("<html lang='es-AR' xml:lang='es-AR' xmlns='http://www.w3.org/1999/xhtml'></html>\n",
+                  render("%html{html_attrs('es-AR')}", :format => :xhtml))
+  end
+
+  def test_html_attrs_html4_other_lang
+    assert_equal("<html lang='es-AR'></html>\n",
+                  render("%html{html_attrs('es-AR')}", :format => :html4))
+  end
+
+  def test_html_attrs_html5_other_lang
+    assert_equal("<html lang='es-AR'></html>\n",
+                  render("%html{html_attrs('es-AR')}", :format => :html5))
+  end
+
   def test_escape_once_should_work_on_frozen_strings
     begin
       Haml::Helpers.escape_once('foo'.freeze)
@@ -580,4 +693,3 @@ HAML
   end
 
 end
-

data/test/options_test.rb

@@ -0,0 +1,22 @@
+require 'test_helper'
+
+module Haml
+  class OptionsTest < Haml::TestCase
+    def test_buffer_defaults_have_only_buffer_option_keys
+      assert_equal(
+        Haml::Options.buffer_option_keys.sort,
+        Haml::Options.buffer_defaults.keys.sort,
+      )
+    end
+
+    def test_buffer_defaults_values_are_the_same_as_rails_defaults
+      rails_defaults = Haml::Options.defaults.merge(Haml::Template.options)
+      Haml::Options.buffer_option_keys.each do |key|
+        assert_equal(
+          rails_defaults[key],
+          Haml::Options.buffer_defaults[key], "key: #{key}"
+        )
+      end
+    end
+  end
+end

data/test/parser_test.rb

@@ -1,7 +1,7 @@
 require 'test_helper'
 
 module Haml
-  class ParserTest < MiniTest::Unit::TestCase
+  class ParserTest < Haml::TestCase
 
     test "should raise error for 'else' at wrong indent level" do
       begin
@@ -94,12 +94,79 @@ module Haml
       end
     end
 
+    test "revealed conditional comments are detected" do
+      text = "some revealed text"
+      cond = "[cond]"
+
+      node = parse("/!#{cond} #{text}").children[0]
+
+      assert_equal text, node.value[:text]
+      assert_equal cond, node.value[:conditional]
+      assert node.value[:revealed]
+    end
+
+    test "hidden conditional comments are detected" do
+      text = "some revealed text"
+      cond = "[cond]"
+
+      node = parse("/#{cond} #{text}").children[0]
+
+      assert_equal text, node.value[:text]
+      assert_equal cond, node.value[:conditional]
+      refute node.value[:revealed]
+    end
+
+    test "only script lines are checked for continuation keywords" do
+      haml = "- if true\n  setup\n- else\n  else\n"
+      node = parse(haml).children[0]
+      assert_equal(3, node.children.size)
+    end
+
+    # see #830. Strictly speaking the pipe here is not necessary, but there
+    # shouldn't be an error if it is there.
+    test "multiline Ruby with extra trailing pipe doesn't raise error" do
+      haml = "%p= foo bar, |\n  baz"
+      begin
+        parse haml
+      rescue Haml::SyntaxError
+        flunk "Should not have raised SyntaxError"
+      end
+    end
+
+    test "empty filter doesn't hide following lines" do
+      root = parse "%p\n  :plain\n  %p\n"
+      p_element = root.children[0]
+      assert_equal 2, p_element.children.size
+      assert_equal :filter, p_element.children[0].type
+      assert_equal :tag, p_element.children[1].type
+    end
+
+    # Previously blocks under a haml_comment would be rejected if any line was
+    # indented by a value that wasn't a multiple of the document indentation.
+    test "haml_comment accepts any indentation in content" do
+      begin
+        parse "-\#\n  Indented two spaces\n   Indented three spaces"
+      rescue Haml::SyntaxError
+        flunk "haml_comment should accept any combination of indentation"
+      end
+    end
+
+    test "block haml_comment includes text" do
+      root = parse "-#\n  Hello\n   Hello\n"
+      assert_equal "Hello\n Hello\n", root.children[0].value[:text]
+    end
+
+    test "block haml_comment includes first line if present" do
+      root = parse "-# First line\n  Hello\n   Hello\n"
+      assert_equal " First line\nHello\n Hello\n", root.children[0].value[:text]
+    end
+
     private
 
     def parse(haml, options = nil)
       options ||= Options.new
-      parser = Parser.new(haml, options)
-      parser.parse
+      parser = Parser.new(options)
+      parser.call(haml)
     end
   end
-end
+end

data/test/results/bemit.xhtml

@@ -0,0 +1,4 @@
+<div class='o-media@md c-user c-user--premium'>
+<img alt='' class='o-media__img@md c-user__photo c-avatar' src='' />
+<p class='o-media__body@md c-user__bio'>...</p>
+</div>

data/test/results/eval_suppressed.xhtml

@@ -2,8 +2,8 @@
 <p></p>
 <h1>Me!</h1>
 <div id='foo'>
-  <p id='bar'>All</p>
-  <br />
-  <p class='baz'>This</p>
-  Should render
+<p id='bar'>All</p>
+<br />
+<p class='baz'>This</p>
+Should render
 </div>