haml 4.0.0 → 5.0.0

data/test/helper_test.rb

@@ -1,22 +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
-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)
@@ -31,15 +22,18 @@ class HelperTest < MiniTest::Unit::TestCase
   end
 
   def setup
-    @base = ActionView::Base.new
-    @base.controller = ActionController::Base.new
-
-    if defined?(ActionController::Response)
-      # This is needed for >=3.0.0
-      @base.controller.response = ActionController::Response.new
-    end
+    @base = Class.new(ActionView::Base) {
+      def nested_tag
+        content_tag(:span) {content_tag(:div) {"something"}}
+      end
 
-    @base.instance_variable_set('@post', Post.new("Foo bar\nbaz", nil, PostErrors.new))
+      def wacky_form
+        form_tag("/foo") {"bar"}
+      end
+    }.new
+    @base.controller = ActionController::Base.new
+    @base.view_paths << File.expand_path("../templates", __FILE__)
+    @base.instance_variable_set(:@post, Post.new("Foo bar\nbaz", nil, PostErrors.new))
   end
 
   def render(text, options = {})
@@ -47,6 +41,32 @@ class HelperTest < MiniTest::Unit::TestCase
     super
   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  &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
     assert_equal("FooBar", Haml::Helpers.flatten("FooBar"))
 
@@ -59,13 +79,13 @@ class HelperTest < MiniTest::Unit::TestCase
   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
 
@@ -75,15 +95,15 @@ class HelperTest < MiniTest::Unit::TestCase
   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
@@ -100,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)
@@ -118,53 +138,67 @@ HAML
   end
 
   def test_form_tag
-    # This is usually provided by ActionController::Base.
     def @base.protect_against_forgery?; false; end
-    assert_equal(<<HTML, render(<<HAML, :action_view))
-<form accept-charset="UTF-8" action="foo" method="post">#{rails_form_opener}
-  <p>bar</p>
-  <strong>baz</strong>
-</form>
-HTML
+    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
   end
 
-  if ActionPack::VERSION::MAJOR == 4
-    def test_text_area
-      assert_equal(%(<textarea id="body" name="body">\nFoo&#x000A;Bar&#x000A; Baz&#x000A;   Boom</textarea>\n),
-                   render('= text_area_tag "body", "Foo\nBar\n Baz\n   Boom"', :action_view))
+  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
 
-      assert_equal(%(<textarea id="post_body" name="post[body]">\nFoo bar&#x000A;baz</textarea>\n),
-                   render('= text_area :post, :body', :action_view))
+  def test_pre
+    assert_equal(%(<pre>Foo bar&#x000A;   baz</pre>\n),
+                 render('= content_tag "pre", "Foo bar\n   baz"', :action_view))
+  end
 
-      assert_equal(%(<pre>Foo bar&#x000A;   baz</pre>\n),
-                   render('= content_tag "pre", "Foo bar\n   baz"', :action_view))
-    end
-  elsif (ActionPack::VERSION::MAJOR == 3) && (ActionPack::VERSION::MINOR >= 2) && (ActionPack::VERSION::TINY >= 3)
-    def test_text_area
-      assert_equal(%(<textarea id="body" name="body">\nFoo&#x000A;Bar&#x000A; Baz&#x000A;   Boom</textarea>\n),
-                   render('= text_area_tag "body", "Foo\nBar\n Baz\n   Boom"', :action_view))
+  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)
+    assert_equal "Foo&#x000A;Bar&#x000A; Baz&#x000A;   Boom", match_data[2]
+  end
 
-      assert_equal(%(<textarea cols="40" id="post_body" name="post[body]" rows="20">\nFoo bar&#x000A;baz</textarea>\n),
-                   render('= text_area :post, :body', :action_view))
+  def test_text_area
+    output = render('= text_area :post, :body', :action_view)
+    match_data = output.match(TEXT_AREA_CONTENT_REGEX)
+    assert_equal "Foo bar&#x000A;baz", match_data[2]
+  end
 
-      assert_equal(%(<pre>Foo bar&#x000A;   baz</pre>\n),
-                   render('= content_tag "pre", "Foo bar\n   baz"', :action_view))
-    end
-  else
-    def test_text_area
-      assert_equal(%(<textarea id="body" name="body">Foo&#x000A;Bar&#x000A; Baz&#x000A;   Boom</textarea>\n),
-                   render('= text_area_tag "body", "Foo\nBar\n Baz\n   Boom"', :action_view))
+  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))
+    output = render(".foo\n  .bar\n    = render '/text_area_helper'", :action_view)
+    match_data = output.match(TEXT_AREA_CONTENT_REGEX)
+    assert_equal 'Foo', match_data[2]
+  end
 
-      assert_equal(%(<textarea cols="40" id="post_body" name="post[body]" rows="20">Foo bar&#x000A;baz</textarea>\n),
-                   render('= text_area :post, :body', :action_view))
+  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
 
-      assert_equal(%(<pre>Foo bar&#x000A;   baz</pre>\n),
-                   render('= content_tag "pre", "Foo bar\n   baz"', :action_view))
-    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
@@ -202,11 +236,10 @@ HAML
 
   def test_form_tag_in_helper_with_string_block
     def @base.protect_against_forgery?; false; end
-    assert_equal(<<HTML, render(<<HAML, :action_view))
-<form accept-charset="UTF-8" action="/foo" method="post">#{rails_form_opener}bar</form>
-HTML
-= wacky_form
-HAML
+    rendered = render('= wacky_form', :action_view)
+    fragment = Nokogiri::HTML.fragment(rendered)
+    assert_equal 'bar', fragment.text.strip
+    assert_equal '/foo', fragment.css('form').first.attributes['action'].to_s
   end
 
   def test_haml_tag_name_attribute_with_id
@@ -265,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
@@ -297,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', :/") }
@@ -320,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
@@ -333,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
@@ -344,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?"))
@@ -365,21 +445,72 @@ 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
     assert_equal("foo\n", render("= capture { 'foo' }", :action_view))
   end
 
+  def test_capture_with_non_string_value_reurns_nil
+    def @base.check_capture_returns_nil(&block)
+      contents = capture(&block)
+
+      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"))
@@ -391,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
 
@@ -428,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
@@ -474,6 +610,14 @@ HAML
     assert_equal "&quot;&gt;&lt;&amp;", Haml::Helpers.html_escape('"><&')
   end
 
+  def test_html_escape_should_work_on_frozen_strings
+    begin
+      assert Haml::Helpers.html_escape('foo'.freeze)
+    rescue => e
+      flunk e.message
+    end
+  end
+
   def test_html_escape_encoding
     old_stderr, $stderr = $stderr, StringIO.new
     string = "\"><&\u00e9" # if you're curious, u00e9 is "LATIN SMALL LETTER E WITH ACUTE"
@@ -483,6 +627,11 @@ HAML
     $stderr = old_stderr
   end
 
+  def test_html_escape_non_string
+    assert_equal('4.58', Haml::Helpers.html_escape(4.58))
+    assert_equal('4.58', Haml::Helpers.html_escape_without_haml_xss(4.58))
+  end
+
   def test_escape_once
     assert_equal "&quot;&gt;&lt;&amp;", Haml::Helpers.escape_once('"><&')
   end
@@ -493,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
@@ -505,5 +654,42 @@ HAML
     $stderr = old_stderr
   end
 
-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)
+    rescue => e
+      flunk e.message
+    end
+  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>