haml 1.8.0 → 2.0.0

data/test/haml/engine_test.rb

@@ -1,15 +1,45 @@
 #!/usr/bin/env ruby
-
-require 'rubygems'
-require 'active_support'
-require 'action_controller'
-require 'action_view'
-
-require 'test/unit'
-require File.dirname(__FILE__) + '/../../lib/haml'
-require 'haml/engine'
+require File.dirname(__FILE__) + '/test_helper'
 
 class EngineTest < Test::Unit::TestCase
+  # A map of erroneous Sass 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.
+  # If this isn't provided, the tests will assume the line number should be the last line of the document.
+  EXCEPTION_MAP = {
+    "!!!\n  a" => "Illegal nesting: nesting within a header command is illegal.",
+    "a\n  b" => "Illegal nesting: nesting within plain text is illegal.",
+    "/ a\n  b" => "Illegal nesting: nesting within a tag that already has content is illegal.",
+    "% a" => 'Invalid tag: "% a".',
+    "%p a\n  b" => "Illegal nesting: content can't be both given on the same line as %p and nested within it.",
+    "%p=" => "There's no Ruby code for = to evaluate.",
+    "%p~" => "There's no Ruby code for ~ to evaluate.",
+    "~" => "There's no Ruby code for ~ to evaluate.",
+    "=" => "There's no Ruby code for = to evaluate.",
+    "%p/\n  a" => "Illegal nesting: nesting within a self-closing tag is illegal.",
+    "%p\n\ta" => <<END.strip,
+A tab character was used for indentation. Haml must be indented using two spaces.
+Are you sure you have soft tabs enabled in your editor?
+END
+    "%p\n a" => "1 space was used for indentation. Haml must be indented using two spaces.",
+    "%p\n   a" => "3 spaces were used for indentation. Haml must be indented using two spaces.",
+    "%p\n    a" => "4 spaces were used for indentation. Haml must be indented using two spaces.",
+    ":a\n  b" => ['Filter "a" is not defined.', 1],
+    ":a= b" => 'Invalid filter name ":a= b".',
+    "." => "Illegal element: classes and ids must have values.",
+    ".#" => "Illegal element: classes and ids must have values.",
+    ".{} a" => "Illegal element: classes and ids must have values.",
+    ".= a" => "Illegal element: classes and ids must have values.",
+    "%p..a" => "Illegal element: classes and ids must have values.",
+    "%a/ b" => "Self-closing tags can't have content.",
+
+    # Regression tests
+    "- raise 'foo'\n\n\n\nbar" => ["foo", 1],
+    "= 'foo'\n-raise 'foo'" => ["foo", 2],
+    "\n\n\n- raise 'foo'" => ["foo", 4],
+  }
+
+  User = Struct.new('User', :id)
 
   def render(text, options = {}, &block)
     scope  = options.delete(:scope)  || Object.new
@@ -22,7 +52,7 @@ class EngineTest < Test::Unit::TestCase
   end
 
   def test_attributes_should_render_correctly
-    assert_equal("<div class='atlantis' style='ugly'>\n</div>", render(".atlantis{:style => 'ugly'}").chomp)
+    assert_equal("<div class='atlantis' style='ugly'></div>", render(".atlantis{:style => 'ugly'}").chomp)
   end
 
   def test_ruby_code_should_work_inside_attributes
@@ -31,7 +61,7 @@ class EngineTest < Test::Unit::TestCase
   end
 
   def test_nil_should_render_empty_tag
-    assert_equal("<div class='no_attributes'>\n</div>",
+    assert_equal("<div class='no_attributes'></div>",
                  render(".no_attributes{:nil => nil}").chomp)
   end
 
@@ -44,20 +74,8 @@ class EngineTest < Test::Unit::TestCase
     assert_equal("<p>Hello</p>", render('%p Hello').chomp)
   end
 
-  def test_long_liner_should_not_print_on_one_line
-    assert_equal("<div>\n  #{'x' * 51}\n</div>", render("%div #{'x' * 51}").chomp)
-  end
-  
-  def test_non_prerendered_one_liner
-    assert_equal("<p class='awesome'>One line</p>\n", render("%p{:class => c} One line", :locals => {:c => 'awesome'}))
-  end
-  
-  def test_non_prerendered_script_one_liner
-    assert_equal("<p class='awesome'>One line</p>\n", render("%p{:class => c}= 'One line'", :locals => {:c => 'awesome'}))
-  end
-  
-  def test_non_prerendered_long_script_one_liner
-    assert_equal("<p class='awesome'>\n  #{'x' * 60}\n</p>\n", render("%p{:class => c}= 'x' * 60", :locals => {:c => 'awesome'}))
+  def test_one_liner_with_newline_shouldnt_be_one_line
+    assert_equal("<p>\n  foo\n  bar\n</p>", render('%p= "foo\nbar"').chomp)
   end
 
   def test_multi_render
@@ -93,36 +111,190 @@ class EngineTest < Test::Unit::TestCase
     assert_equal("<img alt='' src='/foo.png' />\n", render("%img{:width => nil, :src => '/foo.png', :alt => String.new}"))
   end
 
+  def test_end_of_file_multiline
+    assert_equal("<p>0</p>\n<p>1</p>\n<p>2</p>\n", render("- for i in (0...3)\n  %p= |\n   i |"))
+  end
+
+  def test_cr_newline
+    assert_equal("<p>foo</p>\n<p>bar</p>\n<p>baz</p>\n<p>boom</p>\n", render("%p foo\r%p bar\r\n%p baz\n\r%p boom"))
+  end
+
+  def test_textareas
+    assert_equal("<textarea>Foo&#x000A;  bar&#x000A;   baz</textarea>\n",
+                 render('%textarea= "Foo\n  bar\n   baz"'))
+
+    assert_equal("<pre>Foo&#x000A;  bar&#x000A;   baz</pre>\n",
+                 render('%pre= "Foo\n  bar\n   baz"'))
+
+    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))
+%p
+  %textarea
+    Foo
+    Bar
+    Baz
+SOURCE
+  end
+
+  def test_boolean_attributes
+    assert_equal("<p bar baz='true' foo='bar'></p>\n",
+                 render("%p{:foo => 'bar', :bar => true, :baz => 'true'}", :format => :html4))
+    assert_equal("<p bar='bar' baz='true' foo='bar'></p>\n",
+                 render("%p{:foo => 'bar', :bar => true, :baz => 'true'}", :format => :xhtml))
+
+    assert_equal("<p baz='false' foo='bar'></p>\n",
+                 render("%p{:foo => 'bar', :bar => false, :baz => 'false'}", :format => :html4))
+    assert_equal("<p baz='false' foo='bar'></p>\n",
+                 render("%p{:foo => 'bar', :bar => false, :baz => 'false'}", :format => :xhtml))
+  end
+
+  def test_both_whitespace_nukes_work_together
+    assert_equal(<<RESULT, render(<<SOURCE))
+<p><q>Foo
+  Bar</q></p>
+RESULT
+%p
+  %q><= "Foo\\nBar"
+SOURCE
+  end
+
+  # 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))
+  end
+
+  def test_ampersand_equals_inline_should_escape
+    assert_equal("<p>foo &amp; bar</p>\n", render("%p&= 'foo & bar'", :escape_html => false))
+  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))
+  end
+
+  def test_bang_equals_inline_should_not_escape
+    assert_equal("<p>foo & bar</p>\n", render("%p!= 'foo & bar'", :escape_html => true))
+  end
+  
+  def test_static_attributes_should_be_escaped
+    assert_equal("<img class='atlantis' style='ugly&amp;stupid' />\n",
+                 render("%img.atlantis{:style => 'ugly&stupid'}", :escape_html => true))
+    assert_equal("<div class='atlantis' style='ugly&amp;stupid'>foo</div>\n",
+                 render(".atlantis{:style => 'ugly&stupid'} foo", :escape_html => true))
+    assert_equal("<p class='atlantis' style='ugly&amp;stupid'>foo</p>\n",
+                render("%p.atlantis{:style => 'ugly&stupid'}= 'foo'", :escape_html => true))
+  end
+
+  def test_dynamic_attributes_should_be_escaped
+    assert_equal("<img alt='' src='/foo.png' />\n",
+                 render("%img{:width => nil, :src => '/foo.png', :alt => String.new}", :escape_html => true))
+    assert_equal("<p alt='' src='/foo.png'>foo</p>\n",
+                 render("%p{:width => nil, :src => '/foo.png', :alt => String.new} foo", :escape_html => true))
+    assert_equal("<div alt='' src='/foo.png'>foo</div>\n",
+                 render("%div{:width => nil, :src => '/foo.png', :alt => String.new}= 'foo'", :escape_html => true))
+  end
+  
+  def test_string_interpolation_should_be_esaped
+    assert_equal("<p>4&amp;3</p>\n", render("%p== #{2+2}&#{2+1}", :escape_html => true))
+    assert_equal("<p>4&3</p>\n", render("%p== #{2+2}&#{2+1}", :escape_html => false))
+  end
+
+  def test_escaped_inline_string_interpolation
+    assert_equal("<p>4&amp;3</p>\n", render("%p&== #{2+2}&#{2+1}", :escape_html => true))
+    assert_equal("<p>4&amp;3</p>\n", render("%p&== #{2+2}&#{2+1}", :escape_html => false))
+  end
+
+  def test_unescaped_inline_string_interpolation
+    assert_equal("<p>4&3</p>\n", render("%p!== #{2+2}&#{2+1}", :escape_html => true))
+    assert_equal("<p>4&3</p>\n", render("%p!== #{2+2}&#{2+1}", :escape_html => false))
+  end
+
+  def test_escaped_string_interpolation
+    assert_equal("<p>\n  4&amp;3\n</p>\n", render("%p\n  &== #{2+2}&#{2+1}", :escape_html => true))
+    assert_equal("<p>\n  4&amp;3\n</p>\n", render("%p\n  &== #{2+2}&#{2+1}", :escape_html => false))
+  end
+
+  def test_unescaped_string_interpolation
+    assert_equal("<p>\n  4&3\n</p>\n", render("%p\n  !== #{2+2}&#{2+1}", :escape_html => true))
+    assert_equal("<p>\n  4&3\n</p>\n", render("%p\n  !== #{2+2}&#{2+1}", :escape_html => false))
+  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))
+  end
+
+  def test_inline_scripts_should_respect_escape_html_option
+    assert_equal("<p>foo &amp; bar</p>\n", render("%p= 'foo & bar'", :escape_html => true))
+    assert_equal("<p>foo & bar</p>\n", render("%p= 'foo & bar'", :escape_html => false))
+  end
+
+  def test_script_ending_in_comment_should_render_when_html_is_escaped
+    assert_equal("foo&amp;bar\n", render("= 'foo&bar' #comment", :escape_html => true))
+  end
+
   # Options tests
 
+  def test_filename_and_line
+    begin
+      render("\n\n = abc", :filename => 'test', :line => 2)
+    rescue Exception => e
+      assert_kind_of Haml::SyntaxError, e
+      assert_match /test:4/, e.backtrace.first
+    end
+
+    begin
+      render("\n\n= 123\n\n= nil[]", :filename => 'test', :line => 2)
+    rescue Exception => e
+      assert_kind_of NoMethodError, e
+      assert_match /test:6/, e.backtrace.first
+    end
+  end
+
   def test_stop_eval
     assert_equal("", render("= 'Hello'", :suppress_eval => true))
     assert_equal("", render("- puts 'foo'", :suppress_eval => true))
     assert_equal("<div id='foo' yes='no' />\n", render("#foo{:yes => 'no'}/", :suppress_eval => true))
     assert_equal("<div id='foo' />\n", render("#foo{:yes => 'no', :call => a_function() }/", :suppress_eval => true))
     assert_equal("<div />\n", render("%div[1]/", :suppress_eval => true))
-
-    begin
-      assert_equal("", render(":ruby\n  puts 'hello'", :suppress_eval => true))
-    rescue Haml::HamlError => err
-      caught = true
-      assert_equal('"ruby" filter is not defined!', err.message)
-    end
-    assert(caught, "Rendering a ruby filter without evaluating didn't throw an error!")
+    assert_equal("", render(":ruby\n  puts 'hello'", :suppress_eval => true))
   end
 
   def test_attr_wrapper
-    assert_equal("<p strange=*attrs*>\n</p>\n", render("%p{ :strange => 'attrs'}", :attr_wrapper => '*'))
-    assert_equal("<p escaped='quo\"te'>\n</p>\n", render("%p{ :escaped => 'quo\"te'}", :attr_wrapper => '"'))
-    assert_equal("<p escaped=\"q'uo&quot;te\">\n</p>\n", render("%p{ :escaped => 'q\\'uo\"te'}", :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&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 => '"'))
   end
 
   def test_attrs_parsed_correctly
-    assert_equal("<p boom=>biddly='bar => baz'>\n</p>\n", render("%p{'boom=>biddly' => 'bar => baz'}"))
-    assert_equal("<p foo,bar='baz, qux'>\n</p>\n", render("%p{'foo,bar' => 'baz, qux'}"))
-    assert_equal("<p escaped='quo\nte'>\n</p>\n", render("%p{ :escaped => \"quo\\nte\"}"))
-    assert_equal("<p escaped='quo4te'>\n</p>\n", render("%p{ :escaped => \"quo\#{2 + 2}te\"}"))
+    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\nte'></p>\n", render("%p{ :escaped => \"quo\\nte\"}"))
+    assert_equal("<p escaped='quo4te'></p>\n", render("%p{ :escaped => \"quo\#{2 + 2}te\"}"))
+  end
+  
+  def test_correct_parsing_with_brackets
+    assert_equal("<p class='foo'>{tada} foo</p>\n", render("%p{:class => 'foo'} {tada} foo"))
+    assert_equal("<p class='foo'>deep {nested { things }}</p>\n", render("%p{:class => 'foo'} deep {nested { things }}"))
+    assert_equal("<p class='bar foo'>{a { d</p>\n", render("%p{{:class => 'foo'}, :class => 'bar'} {a { d"))
+    assert_equal("<p foo='bar'>a}</p>\n", render("%p{:foo => 'bar'} a}"))
+    
+    foo = []
+    foo[0] = Struct.new('Foo', :id).new
+    assert_equal("<p class='struct_foo' id='struct_foo_new'>New User]</p>\n",
+                 render("%p[foo[0]] New User]", :locals => {:foo => foo}))
+    assert_equal("<p class='prefix_struct_foo' id='prefix_struct_foo_new'>New User]</p>\n",
+                 render("%p[foo[0], :prefix] New User]", :locals => {:foo => foo}))
+
+    foo[0].id = 1
+    assert_equal("<p class='struct_foo' id='struct_foo_1'>New User]</p>\n",
+                 render("%p[foo[0]] New User]", :locals => {:foo => foo}))
+    assert_equal("<p class='prefix_struct_foo' id='prefix_struct_foo_1'>New User]</p>\n",
+                 render("%p[foo[0], :prefix] New User]", :locals => {:foo => foo}))
   end
   
   def test_empty_attrs
@@ -135,61 +307,51 @@ class EngineTest < Test::Unit::TestCase
     assert_equal("<p>nil</p>\n", render("%p{ :attr => x } nil", :locals => {:x => nil}))
   end
 
-  def test_locals
-    assert_equal("<p>Paragraph!</p>\n", render("%p= text", :locals => { :text => "Paragraph!" }))
+  def test_nil_id_with_syntactic_id
+    assert_equal("<p id='foo'>nil</p>\n", render("%p#foo{:id => nil} nil"))
+    assert_equal("<p id='foo_bar'>nil</p>\n", render("%p#foo{{:id => 'bar'}, :id => nil} nil"))
+    assert_equal("<p id='foo_bar'>nil</p>\n", render("%p#foo{{:id => nil}, :id => 'bar'} nil"))
   end
 
-  def test_deprecated_locals_option
-    Kernel.module_eval do
-      def warn_with_stub(msg); end
-      alias_method :warn_without_stub, :warn
-      alias_method :warn, :warn_with_stub
-    end
-
-    assert_equal("<p>Paragraph!</p>\n", Haml::Engine.new("%p= text", :locals => { :text => "Paragraph!" }).render)
+  def test_nil_class_with_syntactic_class
+    assert_equal("<p class='foo'>nil</p>\n", render("%p.foo{:class => nil} nil"))
+    assert_equal("<p class='bar foo'>nil</p>\n", render("%p.bar.foo{:class => nil} nil"))
+    assert_equal("<p class='bar foo'>nil</p>\n", render("%p.foo{{:class => 'bar'}, :class => nil} nil"))
+    assert_equal("<p class='bar foo'>nil</p>\n", render("%p.foo{{:class => nil}, :class => 'bar'} nil"))
+  end
 
-    Kernel.module_eval { alias_method :warn, :warn_without_stub }
+  def test_locals
+    assert_equal("<p>Paragraph!</p>\n", render("%p= text", :locals => { :text => "Paragraph!" }))
   end
 
   def test_dynamic_attrs_shouldnt_register_as_literal_values
-    assert_equal("<p a='b2c'>\n</p>\n", render('%p{:a => "b#{1 + 1}c"}'))
-    assert_equal("<p a='b2c'>\n</p>\n", render("%p{:a => 'b' + (1 + 1).to_s + 'c'}"))
+    assert_equal("<p a='b2c'></p>\n", render('%p{:a => "b#{1 + 1}c"}'))
+    assert_equal("<p a='b2c'></p>\n", render("%p{:a => 'b' + (1 + 1).to_s + 'c'}"))
   end
 
-  def test_rec_merge
-    hash1 = {1=>2, 3=>{5=>7, 8=>9}}
-    hash2 = {4=>5, 3=>{5=>2, 16=>12}}
-    hash3 = {1=>2, 4=>5, 3=>{5=>2, 8=>9, 16=>12}}
-
-    hash1.rec_merge!(hash2)
-    assert_equal(hash3, hash1)
+  def test_dynamic_attrs_with_self_closed_tag
+    assert_equal("<a b='2' />\nc\n", render("%a{'b' => 1 + 1}/\n= 'c'\n"))
   end
 
-  def test_syntax_errors
-    errs = [ "!!!\n  a", "a\n  b", "a\n:foo\nb", "/ a\n  b",
-             "% a", "%p a\n  b", "a\n%p=\nb", "%p=\n  a",
-             "a\n%p~\nb", "a\n~\nb", "a\n~\n  b", "%p~\n  b", "%p/\n  a",
-             "%p\n \t%a b", "%a\n b\nc", "%a\n    b\nc",
-             ":notafilter\n  This isn't\n  a filter!",
-             ".{} a", "\#{} a", ".= 'foo'", "%a/ b", "%p..class", "%p..#." ]
-    errs.each do |err|
+  def test_exceptions
+    EXCEPTION_MAP.each do |key, value|
       begin
-        render(err)
-      rescue Exception => e
-        assert(e.is_a?(Haml::Error), "#{err.dump} doesn't produce Haml::SyntaxError")
+        render(key)
+      rescue Exception => err
+        value = [value] unless value.is_a?(Array)
+
+        assert_equal(value.first, err.message, "Line: #{key}")
+        assert_equal(value[1] || key.split("\n").length, err.backtrace[0].gsub('(haml):', '').to_i, "Line: #{key}")
       else
-        assert(false, "#{err.dump} doesn't produce an exception")
+        assert(false, "Exception not raised for\n#{key}")
       end
     end
   end
 
-  def test_syntax_error
+  def test_exception_line
     render("a\nb\n!!!\n  c\nd")
   rescue Haml::SyntaxError => e
-    assert_equal(e.message, "Illegal Nesting: Nesting within a header command is illegal.")
-    assert_equal("(haml):3", e.backtrace[0])
-  rescue Exception => e
-    assert(false, '"a\nb\n!!!\n  c\nd" doesn\'t produce a Haml::SyntaxError')
+    assert_equal("(haml):4", e.backtrace[0])
   else
     assert(false, '"a\nb\n!!!\n  c\nd" doesn\'t produce an exception')
   end
@@ -218,6 +380,11 @@ class EngineTest < Test::Unit::TestCase
     assert_equal("Unbalanced brackets.", e.message)
   end
 
+  def test_balanced_conditional_comments
+    assert_equal("<!--[if !(IE 6)|(IE 7)]> Bracket: ] <![endif]-->\n",
+                 render("/[if !(IE 6)|(IE 7)] Bracket: ]"))
+  end
+
   def test_no_bluecloth
     Kernel.module_eval do
       def gem_original_require_with_bluecloth(file)
@@ -231,7 +398,7 @@ class EngineTest < Test::Unit::TestCase
     begin
       assert_equal("<h1>Foo</h1>\t<p>- a\n- b</p>\n",
                    Haml::Engine.new(":markdown\n  Foo\n  ===\n  - a\n  - b").to_html)
-    rescue Haml::HamlError => e
+    rescue Haml::Error => e
       if e.message == "Can't run Markdown filter; required 'bluecloth' or 'redcloth', but none were found"
         puts "\nCouldn't require 'bluecloth' or 'redcloth'; skipping a test."
       else
@@ -256,7 +423,7 @@ class EngineTest < Test::Unit::TestCase
 
     begin
       Haml::Engine.new(":redcloth\n  _foo_").to_html
-    rescue Haml::HamlError
+    rescue Haml::Error
     else
       assert(false, "No exception raised!")
     end
@@ -278,7 +445,7 @@ class EngineTest < Test::Unit::TestCase
 
     begin
       Haml::Engine.new(":markdown\n  _foo_").to_html
-    rescue Haml::HamlError
+    rescue Haml::Error
     else
       assert(false, "No exception raised!")
     end
@@ -288,17 +455,33 @@ class EngineTest < Test::Unit::TestCase
     end    
   end
 
+  def test_empty_filter
+    assert_equal(<<END, render(':javascript'))
+<script type='text/javascript'>
+  //<![CDATA[
+    
+  //]]>
+</script>
+END
+  end
+
   def test_local_assigns_dont_modify_class
     assert_equal("bar\n", render("= foo", :locals => {:foo => 'bar'}))
     assert_equal(nil, defined?(foo))
   end
 
   def test_object_ref_with_nil_id
-    user = Struct.new('User', :id).new
+    user = User.new
     assert_equal("<p class='struct_user' id='struct_user_new'>New User</p>\n",
                  render("%p[user] New User", :locals => {:user => user}))
   end
 
+  def test_object_ref_before_attrs
+    user = User.new 42
+    assert_equal("<p class='struct_user' id='struct_user_42' style='width: 100px;'>New User</p>\n",
+                 render("%p[user]{:style => 'width: 100px;'} New User", :locals => {:user => user}))
+  end
+
   def test_non_literal_attributes
     assert_equal("<p a1='foo' a2='bar' a3='baz' />\n",
                  render("%p{a2, a1, :a3 => 'baz'}/",
@@ -346,4 +529,58 @@ class EngineTest < Test::Unit::TestCase
   def test_render_proc_with_binding
     assert_equal("FOO\n", Haml::Engine.new("= upcase").render_proc("foo".instance_eval{binding}).call)
   end
+
+  def test_ugly_true
+    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))
+
+    assert_equal("<p>#{'s' * 75}</p>\n",
+                 render("%p #{'s' * 75}", :ugly => true))
+
+    assert_equal("<p>#{'s' * 75}</p>\n",
+                 render("%p= 's' * 75", :ugly => true))
+  end
+
+  def test_xhtml_output_option
+    assert_equal "<p>\n  <br />\n</p>\n", render("%p\n  %br", :format => :xhtml)
+    assert_equal "<a />\n", render("%a/", :format => :xhtml)
+  end
+
+  def test_arbitrary_output_option
+    assert_raise(Haml::Error, "Invalid output format :html1") { Haml::Engine.new("%br", :format => :html1) }
+  end
+
+  # 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 "<br>\n", render("%br/", :format => :html4)
+  end
+
+  def test_html_renders_empty_node_with_closing_tag
+    assert_equal "<div class='foo'></div>\n", render(".foo", :format => :html4)
+  end
+
+  def test_html_ignores_explicit_self_closing_declaration
+    assert_equal "<a></a>\n", render("%a/", :format => :html4)
+  end
+
+  def test_html_ignores_xml_prolog_declaration
+    assert_equal "", render('!!! XML', :format => :html4)
+  end
+
+  def test_html_has_different_doctype
+    assert_equal %{<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">\n},
+    render('!!!', :format => :html4)
+  end
+
+  # because anything before the doctype triggers quirks mode in IE
+  def test_xml_prolog_and_doctype_dont_result_in_a_leading_whitespace_in_html
+    assert_no_match /^\s+/, render("!!! xml\n!!!", :format => :html4)
+  end
+
+  # HTML5
+  def test_html5_doctype
+    assert_equal %{<!DOCTYPE html>\n}, render('!!!', :format => :html5)
+  end
 end

data/test/haml/helper_test.rb

@@ -1,20 +1,15 @@
 #!/usr/bin/env ruby
-
-require 'rubygems'
-require 'active_support'
-require 'action_controller'
-require 'action_view'
-
-require 'test/unit'
-require File.dirname(__FILE__) + '/../../lib/haml'
+require File.dirname(__FILE__) + '/test_helper'
 require 'haml/template'
 
 class HelperTest < Test::Unit::TestCase
   include Haml::Helpers
+  Post = Struct.new('Post', :body)
   
   def setup
     @base = ActionView::Base.new
     @base.controller = ActionController::Base.new
+    @base.instance_variable_set('@post', Post.new("Foo bar\nbaz"))
   end
 
   def render(text, options = {})
@@ -27,14 +22,14 @@ class HelperTest < Test::Unit::TestCase
   end
 
   def test_flatten
-    assert_equal(flatten("FooBar"), "FooBar")
+    assert_equal("FooBar", flatten("FooBar"))
 
-    assert_equal(flatten("Foo\rBar"), "FooBar")
+    assert_equal("FooBar", flatten("Foo\rBar"))
 
-    assert_equal(flatten("Foo\nBar"), "Foo&#x000A;Bar")
+    assert_equal("Foo&#x000A;Bar", flatten("Foo\nBar"))
 
-    assert_equal(flatten("Hello\nWorld!\nYOU ARE \rFLAT?\n\rOMGZ!"),
-                         "Hello&#x000A;World!&#x000A;YOU ARE FLAT?&#x000A;OMGZ!")
+    assert_equal("Hello&#x000A;World!&#x000A;YOU ARE FLAT?&#x000A;OMGZ!",
+                 flatten("Hello\nWorld!\nYOU ARE \rFLAT?\n\rOMGZ!"))
   end
 
   def test_list_of_should_render_correctly
@@ -85,10 +80,33 @@ class HelperTest < Test::Unit::TestCase
     should_be = "<form action=\"foo\" method=\"post\">\n  <p>bar</p>\n  <strong>baz</strong>\n</form>\n"
     assert_equal(should_be, result)
   end
+
+  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))
+
+    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))    
+
+    assert_equal(%(<pre>Foo bar&#x000A;   baz</pre>\n),
+                 render('= content_tag "pre", "Foo bar\n   baz"', :action_view))    
+  end
   
   def test_capture_haml
     assert_equal("\"<p>13</p>\\n\"\n", render("- foo = capture_haml(13) do |a|\n  %p= a\n= foo.dump"))
   end
+  
+  def test_haml_tag_attribute_html_escaping
+    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'"))
+  end
+
+  def test_haml_tag_non_autoclosed_tags_arent_closed
+    assert_equal("<p>\n</p>\n", render("- haml_tag :p"))
+  end
 
   def test_is_haml
     assert(!ActionView::Base.new.is_haml?)
@@ -123,12 +141,12 @@ class HelperTest < Test::Unit::TestCase
   end
 
   def test_find_and_preserve_with_block
-    assert_equal("<pre>&#x000A;  Foo&#x000A;  Bar&#x000A;</pre>\nFoo\nBar\n",
+    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"))
   end
 
   def test_preserve_with_block
-    assert_equal("<pre>&#x000A;  Foo&#x000A;  Bar&#x000A;</pre>&#x000A;Foo&#x000A;Bar&#x000A;\n",
+    assert_equal("<pre>Foo&#x000A;Bar</pre>&#x000A;Foo&#x000A;Bar\n",
                  render("= preserve do\n  %pre\n    Foo\n    Bar\n  Foo\n  Bar"))
   end
 
@@ -140,12 +158,30 @@ class HelperTest < Test::Unit::TestCase
     context.init_haml_helpers
 
     result = context.capture_haml do
-      context.open :p, :attr => "val" do
+      context.haml_tag :p, :attr => "val" do
         context.puts "Blah"
       end
     end
 
     assert_equal("<p attr='val'>\n  Blah\n</p>\n", result)
   end
+
+  def test_non_haml
+    assert_equal("false\n", render("= non_haml { is_haml? }"))
+  end
+  
+  class ActsLikeTag
+    # We want to be able to have people include monkeypatched ActionView helpers
+    # without redefining is_haml?.
+    # This is accomplished via Object#is_haml?, and this is a test for it.
+    include ActionView::Helpers::TagHelper
+    def to_s
+      content_tag :p, 'some tag content'
+    end
+  end
+
+  def test_random_class_includes_tag_helper
+    assert_equal "<p>some tag content</p>", ActsLikeTag.new.to_s
+  end
 end
 

data/test/haml/results/content_for_layout.xhtml

@@ -1,7 +1,6 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 <html>
-  <head>
-  </head>
+  <head></head>
   <body>
     <div id='content'>
       Lorem ipsum dolor sit amet

data/test/haml/results/eval_suppressed.xhtml

@@ -1,7 +1,5 @@
-<p>
-</p>
-<p>
-</p>
+<p></p>
+<p></p>
 <h1>Me!</h1>
 <div id='foo'>
   <p id='bar'>All</p>