haml 4.1.0.beta.1 → 5.0.0.beta.2

data/test/engine_test.rb

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 require 'test_helper'
 
-class EngineTest < MiniTest::Unit::TestCase
+class EngineTest < Haml::TestCase
   # A map of erroneous Haml documents to the error messages they should produce.
   # The error messages may be arrays;
   # if so, the second element should be the line number that should be reported for the error.
@@ -126,11 +126,11 @@ class EngineTest < MiniTest::Unit::TestCase
   end
 
   def test_flexible_tabulation
-    assert_equal("<p>\n  foo\n</p>\n<q>\n  bar\n  <a>\n    baz\n  </a>\n</q>\n",
+    assert_equal("<p>\nfoo\n</p>\n<q>\nbar\n<a>\nbaz\n</a>\n</q>\n",
                  render("%p\n foo\n%q\n bar\n %a\n  baz"))
-    assert_equal("<p>\n  foo\n</p>\n<q>\n  bar\n  <a>\n    baz\n  </a>\n</q>\n",
+    assert_equal("<p>\nfoo\n</p>\n<q>\nbar\n<a>\nbaz\n</a>\n</q>\n",
                  render("%p\n\tfoo\n%q\n\tbar\n\t%a\n\t\tbaz"))
-    assert_equal("<p>\n      \t \t bar\n   baz\n</p>\n",
+    assert_equal("<p>\n    \t \t bar\n baz\n</p>\n",
                  render("%p\n  :plain\n        \t \t bar\n     baz"))
   end
 
@@ -185,7 +185,7 @@ class EngineTest < MiniTest::Unit::TestCase
   def test_dynamic_attributes_with_no_content
     assert_equal(<<HTML, render(<<HAML))
 <p>
-  <a href='http://haml.info'></a>
+<a href='http://haml.info'></a>
 </p>
 HTML
 %p
@@ -222,7 +222,7 @@ HAML
   end
 
   def test_one_liner_with_newline_shouldnt_be_one_line
-    assert_equal("<p>\n  foo\n  bar\n</p>", render('%p= "foo\nbar"').chomp)
+    assert_equal("<p>foo\nbar</p>", render('%p= "foo\nbar"').chomp)
   end
 
   def test_multi_render
@@ -233,8 +233,31 @@ HAML
   end
 
   def test_interpolation
-    assert_equal("<p>Hello World</p>\n", render('%p Hello #{who}', :locals => {:who => 'World'}))
-    assert_equal("<p>\n  Hello World\n</p>\n", render("%p\n  Hello \#{who}", :locals => {:who => 'World'}))
+    assert_equal("<p>Hello World</p>\n", render('%p Hello #{who}', locals: {who: 'World'}, escape_html: false))
+    assert_equal("<p>\nHello World\n</p>\n", render("%p\n  Hello \#{who}", locals: {who: 'World'}, escape_html: false))
+    assert_equal("<p>Hello World</p>\n", render('%p Hello #{who}', locals: {who: 'World'}, escape_html: true))
+    assert_equal("<p>\nHello World\n</p>\n", render("%p\n  Hello \#{who}", locals: {who: 'World'}, escape_html: true))
+  end
+
+  def test_interpolation_with_instance_var
+    scope = Object.new
+    scope.instance_variable_set(:@who, 'World')
+
+    assert_equal("<p>Hello World</p>\n", render('%p Hello #@who', scope: scope, escape_html: false))
+    assert_equal("<p>\nHello World\n</p>\n", render("%p\n  Hello \#@who", scope: scope, escape_html: false))
+    assert_equal("<p>Hello World</p>\n", render('%p Hello #@who', scope: scope, escape_html: true))
+    assert_equal("<p>\nHello World\n</p>\n", render("%p\n  Hello \#@who", scope: scope, escape_html: true))
+  end
+
+  def test_interpolation_with_global
+    $global_var_for_testing = 'World'
+
+    assert_equal("<p>Hello World</p>\n", render('%p Hello #$global_var_for_testing', escape_html: false))
+    assert_equal("<p>\nHello World\n</p>\n", render("%p\n  Hello \#$global_var_for_testing", escape_html: false))
+    assert_equal("<p>Hello World</p>\n", render('%p Hello #$global_var_for_testing', escape_html: true))
+    assert_equal("<p>\nHello World\n</p>\n", render("%p\n  Hello \#$global_var_for_testing", escape_html: true))
+  ensure
+    $global_var_for_testing = nil
   end
 
   def test_interpolation_in_the_middle_of_a_string
@@ -242,9 +265,43 @@ HAML
                  render("\"title '\#{\"Title\"}'. \""))
   end
 
+  def test_interpolation_with_instance_var_in_the_middle_of_a_string
+    scope = Object.new
+    scope.instance_variable_set(:@title, 'Title')
+
+    assert_equal("\"title 'Title'. \"\n",
+                 render("\"title '\#@title'. \"",  :scope => scope))
+  end
+
+  def test_interpolation_with_global_in_the_middle_of_a_string
+    $global_var_for_testing = 'Title'
+
+    assert_equal("\"title 'Title'. \"\n",
+                 render("\"title '\#$global_var_for_testing'. \""))
+  ensure
+    $global_var_for_testing = nil
+  end
+
   def test_interpolation_at_the_beginning_of_a_line
     assert_equal("<p>2</p>\n", render('%p #{1 + 1}'))
-    assert_equal("<p>\n  2\n</p>\n", render("%p\n  \#{1 + 1}"))
+    assert_equal("<p>\n2\n</p>\n", render("%p\n  \#{1 + 1}"))
+  end
+
+  def test_interpolation_with_instance_var_at_the_beginning_of_a_line
+    scope = Object.new
+    scope.instance_variable_set(:@foo, 2)
+
+    assert_equal("<p>2</p>\n", render('%p #@foo', :scope => scope))
+    assert_equal("<p>\n2\n</p>\n", render("%p\n  \#@foo", :scope => scope))
+  end
+
+  def test_interpolation_with_global_at_the_beginning_of_a_line
+    $global_var_for_testing = 2
+
+    assert_equal("<p>2</p>\n", render('%p #$global_var_for_testing'))
+    assert_equal("<p>\n2\n</p>\n", render("%p\n  \#$global_var_for_testing"))
+  ensure
+    $global_var_for_testing = nil
   end
 
   def test_escaped_interpolation
@@ -269,7 +326,7 @@ HAML
 
   def test_attribute_hash_with_newlines
     assert_equal("<p a='b' c='d'>foop</p>\n", render("%p{:a => 'b',\n   :c => 'd'} foop"))
-    assert_equal("<p a='b' c='d'>\n  foop\n</p>\n", render("%p{:a => 'b',\n   :c => 'd'}\n  foop"))
+    assert_equal("<p a='b' c='d'>\nfoop\n</p>\n", render("%p{:a => 'b',\n   :c => 'd'}\n  foop"))
     assert_equal("<p a='b' c='d'>\n", render("%p{:a => 'b',\n   :c => 'd'}/"))
     assert_equal("<p a='b' c='d' e='f'></p>\n", render("%p{:a => 'b',\n   :c => 'd',\n   :e => 'f'}"))
   end
@@ -288,8 +345,8 @@ HAML
     assert_equal(hash, {:color => 'red'})
   end
 
-  def test_ugly_semi_prerendered_tags
-    assert_equal(<<HTML, render(<<HAML, :ugly => true))
+  def test_semi_prerendered_tags
+    assert_equal(<<HTML, render(<<HAML))
 <p a='2'></p>
 <p a='2'>foo</p>
 <p a='2'>
@@ -331,7 +388,7 @@ HAML
     assert_equal("<textarea>#{'a' * 100}</textarea>\n",
                  render("%textarea #{'a' * 100}"))
 
-    assert_equal("<p>\n  <textarea>Foo\n  Bar\n  Baz</textarea>\n</p>\n", render(<<SOURCE))
+    assert_equal("<p>\n<textarea>Foo\nBar\nBaz</textarea>\n</p>\n", render(<<SOURCE))
 %p
   %textarea
     Foo
@@ -378,7 +435,7 @@ HAML
   def test_both_whitespace_nukes_work_together
     assert_equal(<<RESULT, render(<<SOURCE))
 <p><q>Foo
-  Bar</q></p>
+Bar</q></p>
 RESULT
 %p
   %q><= "Foo\\nBar"
@@ -387,6 +444,7 @@ SOURCE
 
   def test_nil_option
     assert_equal("<p foo='bar'></p>\n", render('%p{:foo => "bar"}', :attr_wrapper => nil))
+    assert_equal("<p foo='bar'></p>\n", render('%p{foo: "bar"}', :attr_wrapper => nil))
   end
 
   def test_comment_with_crazy_nesting
@@ -408,11 +466,11 @@ HAML
   def test_indentation_after_dynamic_attr_hash
     assert_equal(<<HTML, render(<<HAML))
 <html>
-  <body>
-    <img src='test'>
-    foo
-    bar
-  </body>
+<body>
+<img src='test'>
+foo
+bar
+</body>
 </html>
 HTML
 %html
@@ -423,10 +481,12 @@ HAML
   end
 
   def test_whitespace_nuke_with_both_newlines
-    assert_equal("<p>foo</p>\n", render('%p<= "\nfoo\n"'))
+    assert_equal("<p>\nfoo\n</p>\n", render('%p<= "\nfoo\n"'))
     assert_equal(<<HTML, render(<<HAML))
 <p>
-  <p>foo</p>
+<p>
+foo
+</p>
 </p>
 HTML
 %p
@@ -437,7 +497,7 @@ HAML
   def test_whitespace_nuke_with_tags_and_else
     assert_equal(<<HTML, render(<<HAML))
 <a>
-  <b>foo</b>
+<b>foo</b>
 </a>
 HTML
 %a
@@ -450,9 +510,9 @@ HAML
 
     assert_equal(<<HTML, render(<<HAML))
 <a>
-  <b>
-    foo
-  </b>
+<b>
+foo
+</b>
 </a>
 HTML
 %a
@@ -467,7 +527,7 @@ HAML
   def test_outer_whitespace_nuke_with_empty_script
     assert_equal(<<HTML, render(<<HAML))
 <p>
-  foo<a></a></p>
+foo  <a></a></p>
 HTML
 %p
   foo
@@ -479,7 +539,7 @@ HAML
   def test_both_case_indentation_work_with_deeply_nested_code
     result = <<RESULT
 <h2>
-  other
+other
 </h2>
 RESULT
     assert_equal(result, render(<<HAML))
@@ -502,15 +562,15 @@ HAML
 HAML
   end
 
-  def test_equals_block_with_ugly
-    assert_equal("foo\n", render(<<HAML, :ugly => true))
+  def test_equals_block
+    assert_equal("foo\n", render(<<HAML))
 = capture_haml do
   foo
 HAML
   end
 
-  def test_plain_equals_with_ugly
-    assert_equal("foo\nbar\n", render(<<HAML, :ugly => true))
+  def test_plain_equals
+    assert_equal("foo\nbar\n", render(<<HAML))
 = "foo"
 bar
 HAML
@@ -528,10 +588,7 @@ HAML
   end
 
   def test_end_with_method_call
-    assert_equal(<<HTML, render(<<HAML))
-2|3|4
-b-a-r
-HTML
+    assert_equal("2|3|4b-a-r", render(<<HAML))
 = [1, 2, 3].map do |i|
   - i + 1
 - end.join("|")
@@ -545,9 +602,7 @@ HAML
   def test_nested_end_with_method_call
     assert_equal(<<HTML, render(<<HAML))
 <p>
-  2|3|4
-  b-a-r
-</p>
+2|3|4b-a-r</p>
 HTML
 %p
   = [1, 2, 3].map do |i|
@@ -629,7 +684,7 @@ HAML
   def test_escape_attrs_false
     assert_equal(<<HTML, render(<<HAML, :escape_attrs => false))
 <div class='<?php echo "&quot;" ?>' id='foo'>
-  bar
+bar
 </div>
 HTML
 #foo{:class => '<?php echo "&quot;" ?>'}
@@ -638,9 +693,9 @@ HAML
   end
 
   def test_escape_attrs_always
-    assert_equal(<<HTML, render(<<HAML, :escape_attrs => :always))
-<div class='"&amp;lt;&amp;gt;&amp;amp;"' id='foo'>
-  bar
+    assert_equal(<<HTML, render(<<HAML, :escape_attrs => true))
+<div class='&quot;&amp;lt;&amp;gt;&amp;amp;&quot;' id='foo'>
+bar
 </div>
 HTML
 #foo{:class => '"&lt;&gt;&amp;"'}
@@ -760,7 +815,7 @@ HAML
     assert_equal("<a href='#'>Foo</a>\n",
       render('%a(href="#") #{"Foo"}'))
 
-    assert_equal("<a href='#\"'></a>\n", render('%a(href="#\\"")'))
+    assert_equal("<a href='#&quot;'></a>\n", render('%a(href="#\\"")'))
   end
 
   def test_case_assigned_to_var
@@ -889,7 +944,7 @@ HAML
   # HTML escaping tests
 
   def test_ampersand_equals_should_escape
-    assert_equal("<p>\n  foo &amp; bar\n</p>\n", render("%p\n  &= 'foo & bar'", :escape_html => false))
+    assert_equal("<p>\nfoo &amp; bar\n</p>\n", render("%p\n  &= 'foo & bar'", :escape_html => false))
   end
 
   def test_ampersand_equals_inline_should_escape
@@ -901,7 +956,7 @@ HAML
   end
 
   def test_bang_equals_should_not_escape
-    assert_equal("<p>\n  foo & bar\n</p>\n", render("%p\n  != 'foo & bar'", :escape_html => true))
+    assert_equal("<p>\nfoo & bar\n</p>\n", render("%p\n  != 'foo & bar'", :escape_html => true))
   end
 
   def test_bang_equals_inline_should_not_escape
@@ -915,8 +970,6 @@ HAML
                  render(".atlantis{:style => 'ugly&stupid'} foo"))
     assert_equal("<p class='atlantis' style='ugly&amp;stupid'>foo</p>\n",
                 render("%p.atlantis{:style => 'ugly&stupid'}= 'foo'"))
-    assert_equal("<p class='atlantis' style='ugly&#x000A;stupid'></p>\n",
-                render("%p.atlantis{:style => \"ugly\\nstupid\"}"))
   end
 
   def test_dynamic_attributes_should_be_escaped
@@ -926,8 +979,6 @@ HAML
                  render("%p{:width => nil, :src => '&foo.png', :alt => String.new} foo"))
     assert_equal("<div alt='' src='&amp;foo.png'>foo</div>\n",
                  render("%div{:width => nil, :src => '&foo.png', :alt => String.new}= 'foo'"))
-    assert_equal("<img alt='' src='foo&#x000A;.png'>\n",
-                 render("%img{:width => nil, :src => \"foo\\n.png\", :alt => String.new}"))
   end
 
   def test_string_double_equals_should_be_esaped
@@ -946,13 +997,13 @@ HAML
   end
 
   def test_escaped_string_double_equals
-    assert_equal("<p>\n  4&&lt;\n</p>\n", render("%p\n  &== \#{2+2}&\#{'<'}", :escape_html => true))
-    assert_equal("<p>\n  4&&lt;\n</p>\n", render("%p\n  &== \#{2+2}&\#{'<'}", :escape_html => false))
+    assert_equal("<p>\n4&&lt;\n</p>\n", render("%p\n  &== \#{2+2}&\#{'<'}", :escape_html => true))
+    assert_equal("<p>\n4&&lt;\n</p>\n", render("%p\n  &== \#{2+2}&\#{'<'}", :escape_html => false))
   end
 
   def test_unescaped_string_double_equals
-    assert_equal("<p>\n  4&<\n</p>\n", render("%p\n  !== \#{2+2}&\#{'<'}", :escape_html => true))
-    assert_equal("<p>\n  4&<\n</p>\n", render("%p\n  !== \#{2+2}&\#{'<'}", :escape_html => false))
+    assert_equal("<p>\n4&<\n</p>\n", render("%p\n  !== \#{2+2}&\#{'<'}", :escape_html => true))
+    assert_equal("<p>\n4&<\n</p>\n", render("%p\n  !== \#{2+2}&\#{'<'}", :escape_html => false))
   end
 
   def test_string_interpolation_should_be_esaped
@@ -971,18 +1022,28 @@ HAML
   end
 
   def test_escaped_string_interpolation
-    assert_equal("<p>\n  4&&lt;\n</p>\n", render("%p\n  & \#{2+2}&\#{'<'}", :escape_html => true))
-    assert_equal("<p>\n  4&&lt;\n</p>\n", render("%p\n  & \#{2+2}&\#{'<'}", :escape_html => false))
+    assert_equal("<p>\n4&&lt;\n</p>\n", render("%p\n  & \#{2+2}&\#{'<'}", :escape_html => true))
+    assert_equal("<p>\n4&&lt;\n</p>\n", render("%p\n  & \#{2+2}&\#{'<'}", :escape_html => false))
+  end
+
+  def test_escaped_string_interpolation_with_no_space
+    assert_equal("&lt;br&gt;\n", render('&#{"<br>"}'))
+    assert_equal("<span>&lt;br&gt;</span>\n", render('%span&#{"<br>"}'))
   end
 
   def test_unescaped_string_interpolation
-    assert_equal("<p>\n  4&<\n</p>\n", render("%p\n  ! \#{2+2}&\#{'<'}", :escape_html => true))
-    assert_equal("<p>\n  4&<\n</p>\n", render("%p\n  ! \#{2+2}&\#{'<'}", :escape_html => false))
+    assert_equal("<p>\n4&<\n</p>\n", render("%p\n  ! \#{2+2}&\#{'<'}", :escape_html => true))
+    assert_equal("<p>\n4&<\n</p>\n", render("%p\n  ! \#{2+2}&\#{'<'}", :escape_html => false))
+  end
+
+  def test_unescaped_string_interpolation_with_no_space
+    assert_equal("<br>\n", render('!#{"<br>"}'))
+    assert_equal("<span><br></span>\n", render('%span!#{"<br>"}'))
   end
 
   def test_scripts_should_respect_escape_html_option
-    assert_equal("<p>\n  foo &amp; bar\n</p>\n", render("%p\n  = 'foo & bar'", :escape_html => true))
-    assert_equal("<p>\n  foo & bar\n</p>\n", render("%p\n  = 'foo & bar'", :escape_html => false))
+    assert_equal("<p>\nfoo &amp; bar\n</p>\n", render("%p\n  = 'foo & bar'", :escape_html => true))
+    assert_equal("<p>\nfoo & bar\n</p>\n", render("%p\n  = 'foo & bar'", :escape_html => false))
   end
 
   def test_inline_scripts_should_respect_escape_html_option
@@ -1061,9 +1122,9 @@ HAML
 
   def test_attr_wrapper
     assert_equal("<p strange=*attrs*></p>\n", render("%p{ :strange => 'attrs'}", :attr_wrapper => '*'))
-    assert_equal("<p escaped='quo\"te'></p>\n", render("%p{ :escaped => 'quo\"te'}", :attr_wrapper => '"'))
-    assert_equal("<p escaped=\"quo'te\"></p>\n", render("%p{ :escaped => 'quo\\'te'}", :attr_wrapper => '"'))
-    assert_equal("<p escaped=\"q'uo&#x0022;te\"></p>\n", render("%p{ :escaped => 'q\\'uo\"te'}", :attr_wrapper => '"'))
+    assert_equal("<p escaped=\"quo&quot;te\"></p>\n", render("%p{ :escaped => 'quo\"te'}", :attr_wrapper => '"'))
+    assert_equal("<p escaped=\"quo&#39;te\"></p>\n", render("%p{ :escaped => 'quo\\'te'}", :attr_wrapper => '"'))
+    assert_equal("<p escaped=\"q&#39;uo&quot;te\"></p>\n", render("%p{ :escaped => 'q\\'uo\"te'}", :attr_wrapper => '"'))
     assert_equal("<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n", render("!!! XML", :attr_wrapper => '"', :format => :xhtml))
   end
 
@@ -1081,9 +1142,7 @@ HAML
   end
 
   def test_attrs_parsed_correctly
-    assert_equal("<p boom=>biddly='bar =&gt; baz'></p>\n", render("%p{'boom=>biddly' => 'bar => baz'}"))
     assert_equal("<p foo,bar='baz, qux'></p>\n", render("%p{'foo,bar' => 'baz, qux'}"))
-    assert_equal("<p escaped='quo&#x000A;te'></p>\n", render("%p{ :escaped => \"quo\\nte\"}"))
     assert_equal("<p escaped='quo4te'></p>\n", render("%p{ :escaped => \"quo\#{2 + 2}te\"}"))
   end
 
@@ -1189,10 +1248,10 @@ HAML
   def test_compile_error
     render("a\nb\n- fee)\nc")
   rescue Exception => e
-    assert_match(/\(test_compile_error\):3: (syntax error|expecting \$end)/i, e.message)
+    assert_match(/\(test_compile_error\):3:/i, e.message)
+    assert_match(/(syntax error|expecting \$end)/i, e.message)
   else
-    assert(false,
-           '"a\nb\n- fee)\nc" doesn\'t produce an exception!')
+    assert(false, '"a\nb\n- fee)\nc" doesn\'t produce an exception!')
   end
 
   def test_unbalanced_brackets
@@ -1201,6 +1260,21 @@ HAML
     assert_equal(Haml::Error.message(:unbalanced_brackets), e.message)
   end
 
+  def test_single_line_comments_are_interpolated
+    assert_equal("<!-- Hello 2 -->\n",
+                 render('/ Hello #{1 + 1}'))
+  end
+
+  def test_single_line_comments_are_not_interpolated_with_suppress_eval
+    assert_equal("<!--  -->\n",
+                 render('/ Hello #{1 + 1}', :suppress_eval => true))
+  end
+
+  def test_single_line_comments_with_interpolation_dont_break_tabulation
+    assert_equal("<!-- Hello 2 -->\nconcatted\n",
+                 render("/ Hello \#{1 + 1}\n- haml_concat 'concatted'"))
+  end
+
   def test_balanced_conditional_comments
     assert_equal("<!--[if !(IE 6)|(IE 7)]> Bracket: ] <![endif]-->\n",
                  render("/[if !(IE 6)|(IE 7)] Bracket: ]"))
@@ -1212,13 +1286,13 @@ HAML
   end
 
   def test_downlevel_revealed_conditional_comments_block
-    assert_equal("<!--[if !IE]><!-->\n  A comment\n<!--<![endif]-->\n",
+    assert_equal("<!--[if !IE]><!-->\nA comment\n<!--<![endif]-->\n",
                   render("/![if !IE]\n  A comment"))
   end
 
   def test_local_assigns_dont_modify_class
     assert_equal("bar\n", render("= foo", :locals => {:foo => 'bar'}))
-    assert_equal(nil, defined?(foo))
+    assert_nil(defined?(foo))
   end
 
   def test_object_ref_with_nil_id
@@ -1253,7 +1327,7 @@ HAML
 
   def test_render_should_accept_a_binding_as_scope
     string = "This is a string!"
-    string.instance_variable_set("@var", "Instance variable")
+    string.instance_variable_set(:@var, "Instance variable")
     b = string.instance_eval do
       var = "Local variable"
       # Silence unavoidable warning; Ruby doesn't know we're going to use this
@@ -1334,15 +1408,15 @@ HAML
     end
   end
 
-  def test_ugly_true
+  def test_spacing_inside_tag
     assert_equal("<div id='outer'>\n<div id='inner'>\n<p>hello world</p>\n</div>\n</div>\n",
-                 render("#outer\n  #inner\n    %p hello world", :ugly => true))
+                 render("#outer\n  #inner\n    %p hello world"))
 
     assert_equal("<p>#{'s' * 75}</p>\n",
-                 render("%p #{'s' * 75}", :ugly => true))
+                 render("%p #{'s' * 75}"))
 
     assert_equal("<p>#{'s' * 75}</p>\n",
-                 render("%p= 's' * 75", :ugly => true))
+                 render("%p= 's' * 75"))
   end
 
   def test_remove_whitespace_true
@@ -1359,15 +1433,13 @@ HAML
                  render('%div <span>foo</span> <span>bar</span>', :remove_whitespace => true))
   end
 
-  def test_auto_preserve_unless_ugly
+  def test_auto_preserve
     assert_equal("<pre>foo&#x000A;bar</pre>\n", render('%pre="foo\nbar"'))
     assert_equal("<pre>foo\nbar</pre>\n", render("%pre\n  foo\n  bar"))
-    assert_equal("<pre>foo\nbar</pre>\n", render('%pre="foo\nbar"', :ugly => true))
-    assert_equal("<pre>foo\nbar</pre>\n", render("%pre\n  foo\n  bar", :ugly => true))
   end
 
   def test_xhtml_output_option
-    assert_equal "<p>\n  <br />\n</p>\n", render("%p\n  %br", :format => :xhtml)
+    assert_equal "<p>\n<br />\n</p>\n", render("%p\n  %br", :format => :xhtml)
     assert_equal "<a />\n", render("%a/", :format => :xhtml)
   end
 
@@ -1400,6 +1472,8 @@ HAML
     engine = Haml::Engine.new('%a{:b => "a #$global_var_for_testing b"}')
     $global_var_for_testing = 'bar'
     assert_equal("<a b='a bar b'></a>\n", engine.to_html)
+  ensure
+    $global_var_for_testing = nil
   end
 
   def test_utf8_attrs
@@ -1410,7 +1484,7 @@ HAML
   # HTML 4.0
 
   def test_html_has_no_self_closing_tags
-    assert_equal "<p>\n  <br>\n</p>\n", render("%p\n  %br", :format => :html4)
+    assert_equal "<p>\n<br>\n</p>\n", render("%p\n  %br", :format => :html4)
     assert_equal "<br>\n", render("%br/", :format => :html4)
   end
 
@@ -1454,7 +1528,7 @@ HAML
       render("%div{:data => {:one_plus_one => 1+1}}",
         :hyphenate_data_attrs => false))
 
-    assert_equal("<div data-foo='Here&#x0027;s a \"quoteful\" string.'></div>\n",
+    assert_equal("<div data-foo='Here&#39;s a &quot;quoteful&quot; string.'></div>\n",
       render(%{%div{:data => {:foo => %{Here's a "quoteful" string.}}}},
         :hyphenate_data_attrs => false)) #'
   end
@@ -1507,24 +1581,23 @@ HAML
   end
 
   def test_html5_data_attributes_with_attr_method
-    Haml::Helpers.module_eval do
-      def data_hash
-        {:data => {:foo => "bar", :baz => "bang"}}
-      end
+    obj = Object.new
+    def obj.data_hash
+      {:data => {:foo => "bar", :baz => "bang"}}
+    end
 
-      def data_val
-        {:data => "dat"}
-      end
+    def obj.data_val
+      {:data => "dat"}
     end
 
     assert_equal("<div data-baz='bang' data-brat='wurst' data-foo='blip'></div>\n",
-      render("%div{data_hash, :data => {:foo => 'blip', :brat => 'wurst'}}"))
+      render("%div{data_hash, :data => {:foo => 'blip', :brat => 'wurst'}}", scope: obj))
     assert_equal("<div data-baz='bang' data-foo='blip'></div>\n",
-      render("%div{data_hash, 'data-foo' => 'blip'}"))
+      render("%div{data_hash, 'data-foo' => 'blip'}", scope: obj))
     assert_equal("<div data-baz='bang' data-foo='bar' data='dat'></div>\n",
-      render("%div{data_hash, :data => 'dat'}"))
+      render("%div{data_hash, :data => 'dat'}", scope: obj))
     assert_equal("<div data-brat='wurst' data-foo='blip' data='dat'></div>\n",
-      render("%div{data_val, :data => {:foo => 'blip', :brat => 'wurst'}}"))
+      render("%div{data_val, :data => {:foo => 'blip', :brat => 'wurst'}}", scope: obj))
   end
 
   def test_html5_data_attributes_with_identical_attribute_values
@@ -1536,8 +1609,8 @@ HAML
     assert_equal(<<XML, render(<<HAML, { :format => :html5, :mime_type => 'text/xml' }))
 <?xml version='1.0' encoding='utf-8' ?>
 <root>
-  <element />
-  <hr />
+<element />
+<hr />
 </root>
 XML
 !!! XML
@@ -1551,8 +1624,8 @@ HAML
     assert_equal(<<XML, render(<<HAML, { :format => :html4, :mime_type => 'text/xml' }))
 <?xml version='1.0' encoding='utf-8' ?>
 <root>
-  <element />
-  <hr />
+<element />
+<hr />
 </root>
 XML
 !!! XML
@@ -1618,10 +1691,10 @@ HAML
 
   def test_new_attribute_parsing
     assert_equal("<a a2='b2'>bar</a>\n", render("%a(a2=b2) bar", :locals => {:b2 => 'b2'}))
-    assert_equal(%Q{<a a='foo"bar'>bar</a>\n}, render(%q{%a(a="#{'foo"bar'}") bar})) #'
-    assert_equal(%Q{<a a="foo'bar">bar</a>\n}, render(%q{%a(a="#{"foo'bar"}") bar})) #'
-    assert_equal(%Q{<a a='foo"bar'>bar</a>\n}, render(%q{%a(a='foo"bar') bar}))
-    assert_equal(%Q{<a a="foo'bar">bar</a>\n}, render(%q{%a(a="foo'bar") bar}))
+    assert_equal(%Q{<a a='foo&quot;bar'>bar</a>\n}, render(%q{%a(a="#{'foo"bar'}") bar})) #'
+    assert_equal(%Q{<a a='foo&#39;bar'>bar</a>\n}, render(%q{%a(a="#{"foo'bar"}") bar})) #'
+    assert_equal(%Q{<a a='foo&quot;bar'>bar</a>\n}, render(%q{%a(a='foo"bar') bar}))
+    assert_equal(%Q{<a a='foo&#39;bar'>bar</a>\n}, render(%q{%a(a="foo'bar") bar}))
     assert_equal("<a a:b='foo'>bar</a>\n", render("%a(a:b='foo') bar"))
     assert_equal("<a a='foo' b='bar'>bar</a>\n", render("%a(a = 'foo' b = 'bar') bar"))
     assert_equal("<a a='foo' b='bar'>bar</a>\n", render("%a(a = foo b = bar) bar", :locals => {:foo => 'foo', :bar => 'bar'}))
@@ -1631,11 +1704,11 @@ HAML
   end
 
   def test_new_attribute_escaping
-    assert_equal(%Q{<a a='foo " bar'>bar</a>\n}, render(%q{%a(a="foo \" bar") bar}))
-    assert_equal(%Q{<a a='foo \\" bar'>bar</a>\n}, render(%q{%a(a="foo \\\\\" bar") bar}))
+    assert_equal(%Q{<a a='foo &quot; bar'>bar</a>\n}, render(%q{%a(a="foo \" bar") bar}))
+    assert_equal(%Q{<a a='foo \\&quot; bar'>bar</a>\n}, render(%q{%a(a="foo \\\\\" bar") bar}))
 
-    assert_equal(%Q{<a a="foo ' bar">bar</a>\n}, render(%q{%a(a='foo \' bar') bar}))
-    assert_equal(%Q{<a a="foo \\' bar">bar</a>\n}, render(%q{%a(a='foo \\\\\' bar') bar}))
+    assert_equal(%Q{<a a='foo &#39; bar'>bar</a>\n}, render(%q{%a(a='foo \' bar') bar}))
+    assert_equal(%Q{<a a='foo \\&#39; bar'>bar</a>\n}, render(%q{%a(a='foo \\\\\' bar') bar}))
 
     assert_equal(%Q{<a a='foo \\ bar'>bar</a>\n}, render(%q{%a(a="foo \\\\ bar") bar}))
     assert_equal(%Q{<a a='foo \#{1 + 1} bar'>bar</a>\n}, render(%q{%a(a="foo \#{1 + 1} bar") bar}))
@@ -1664,6 +1737,8 @@ HAML
     locals = {:b => 'b', :d => 'd'}
     assert_equal("<p a='b' c='d'></p>\n", render("%p{:a => b}(c=d)", :locals => locals))
     assert_equal("<p a='b' c='d'></p>\n", render("%p(a=b){:c => d}", :locals => locals))
+
+    assert_equal("<p id='b_d'></p>\n<p id='b_d'></p>\n", render("%p(id=b){id:d}\n%p(id=b){id:d}", locals: locals))
   end
 
   # Ruby Multiline
@@ -1763,8 +1838,7 @@ HAML
 
   def test_loud_ruby_multiline_with_block
     assert_equal(<<HTML, render(<<HAML))
-#{%w[far faz fang]}
-<p>foo</p>
+#{%w[far faz fang]}<p>foo</p>
 <p>bar</p>
 HTML
 = ["bar",
@@ -1877,7 +1951,7 @@ HAML
   def test_utf_8_bom
     assert_equal <<HTML, render(<<HAML)
 <div class='foo'>
-  <p>baz</p>
+<p>baz</p>
 </div>
 HTML
 \xEF\xBB\xBF.foo
@@ -1986,6 +2060,28 @@ HAML
     end
   end
 
+  def test_tracing
+    result = render('%p{:class => "hello"}', :trace => true, :filename => 'foo').strip
+    assert_equal "<p class='hello' data-trace='foo:1'></p>", result
+  end
+
+  def test_unsafe_dynamic_attribute_name_raises_invalid_attribute_name_error
+    assert_raises(Haml::InvalidAttributeNameError) do
+      render(<<-HAML)
+- params = { 'x /><script>alert(1);</script><div x' => 'hello' }
+%div{ data: params }
+      HAML
+    end
+  end
+
+  def test_unsafe_static_attribute_name_raises_invalid_attribute_name_error
+    assert_raises(Haml::InvalidAttributeNameError) do
+      render(<<-HAML)
+%div{ 'x /><script>alert(1);</script><div x' => 'hello' }
+      HAML
+    end
+  end
+
   private
 
   def assert_valid_encoding_comment(comment)