haml 3.2.0.alpha.10 → 3.2.0.alpha.13

data/test/{haml/spec → haml-spec}/tests.json

@@ -114,6 +114,19 @@
       }
     },
 
+    "a self-closing tag ('/' modifier + XHTML)" : {
+      "haml" : "%zzz/",
+      "html" : "<zzz />"
+    },
+
+    "a self-closing tag ('/' modifier + HTML5)" : {
+      "haml" : "%zzz/",
+      "html" : "<zzz>",
+      "config" : {
+        "format" : "html5"
+      }
+    },
+
     "a tag with a CSS class" : {
       "haml" : "%p.class1",
       "html" : "<p class='class1'></p>"
@@ -157,7 +170,7 @@
     "multiple simple Haml tags" : {
       "haml" : "%div\n  %div\n    %p",
       "html" : "<div>\n  <div>\n    <p></p>\n  </div>\n</div>"
-	}
+    }
   },
 
   "tags with unusual HTML characters" : {
@@ -204,22 +217,21 @@
       "haml" : ".--",
       "html" : "<div class='--'></div>"
     }
-
   },
 
   "tags with inline content" : {
 
-    "a simple tag" : {
+    "Inline content simple tag" : {
       "haml" : "%p hello",
       "html" : "<p>hello</p>"
     },
 
-    "a tag with CSS" : {
+    "Inline content tag with CSS" : {
       "haml" : "%p.class1 hello",
       "html" : "<p class='class1'>hello</p>"
     },
 
-    "multiple simple tags" : {
+    "Inline content multiple simple tags" : {
       "haml" : "%div\n  %div\n    %p text",
       "html" : "<div>\n  <div>\n    <p>text</p>\n  </div>\n</div>"
     }
@@ -227,41 +239,40 @@
 
   "tags with nested content" : {
 
-    "a simple tag" : {
+    "Nested content simple tag" : {
       "haml" : "%p\n  hello",
       "html" : "<p>\n  hello\n</p>"
     },
 
-    "a tag with CSS" : {
+    "Nested content tag with CSS" : {
       "haml" : "%p.class1\n  hello",
       "html" : "<p class='class1'>\n  hello\n</p>"
     },
 
-    "multiple simple tags" : {
+    "Nested content multiple simple tags" : {
       "haml" : "%div\n  %div\n    %p\n      text",
       "html" : "<div>\n  <div>\n    <p>\n      text\n    </p>\n  </div>\n</div>"
     }
-
   },
 
   "tags with HTML-style attributes": {
 
-    "one attribute" : {
+    "HTML-style one attribute" : {
       "haml" : "%p(a='b')",
       "html" : "<p a='b'></p>"
     },
 
-    "multiple attributes" : {
+    "HTML-style multiple attributes" : {
       "haml" : "%p(a='b' c='d')",
       "html" : "<p a='b' c='d'></p>"
     },
 
-    "attributes separated with newlines" : {
+    "HTML-style attributes separated with newlines" : {
       "haml" : "%p(a='b'\n  c='d')",
       "html" : "<p a='b' c='d'></p>"
     },
 
-    "an interpolated attribute" : {
+    "HTML-style interpolated attribute" : {
       "haml" : "%p(a=\"#{var}\")",
       "html" : "<p a='value'></p>",
       "locals" : {
@@ -269,27 +280,27 @@
       }
     },
 
-    "'class' as an attribute" : {
+    "HTML-style 'class' as an attribute" : {
       "haml" : "%p(class='class1')",
       "html" : "<p class='class1'></p>"
     },
 
-    "a tag with a CSS class and 'class' as an attribute" : {
+    "HTML-style tag with a CSS class and 'class' as an attribute" : {
       "haml" : "%p.class2(class='class1')",
       "html" : "<p class='class1 class2'></p>"
     },
 
-    "a tag with 'id' as an attribute" : {
+    "HTML-style tag with 'id' as an attribute" : {
       "haml" : "%p(id='1')",
       "html" : "<p id='1'></p>"
     },
 
-    "a tag with a CSS id and 'id' as an attribute" : {
+    "HTML-style tag with a CSS id and 'id' as an attribute" : {
       "haml" : "%p#id(id='1')",
       "html" : "<p id='id_1'></p>"
     },
 
-    "a tag with a variable attribute" : {
+    "HTML-style tag with a variable attribute" : {
       "haml" : "%p(class=var)",
       "html" : "<p class='hello'></p>",
       "locals" : {
@@ -297,7 +308,7 @@
       }
     },
 
-    "a tag with a CSS class and 'class' as a variable attribute" : {
+    "HTML-style tag with a CSS class and 'class' as a variable attribute" : {
       "haml" : ".hello(class=var)",
       "html" : "<div class='hello world'></div>",
       "locals" : {
@@ -305,119 +316,139 @@
       }
     },
 
-    "a tag multiple CSS classes (sorted correctly)" : {
+    "HTML-style tag multiple CSS classes (sorted correctly)" : {
       "haml" : ".z(class=var)",
       "html" : "<div class='a z'></div>",
       "locals" : {
         "var" : "a"
       }
     }
-
   },
 
   "tags with Ruby-style attributes": {
 
-    "one attribute" : {
+    "Ruby-style one attribute" : {
       "haml" : "%p{:a => 'b'}",
-      "html" : "<p a='b'></p>"
+      "html" : "<p a='b'></p>",
+      "optional" : true
     },
 
-    "attributes hash with whitespace" : {
+    "Ruby-style attributes hash with whitespace" : {
       "haml" : "%p{  :a  =>  'b'  }",
-      "html" : "<p a='b'></p>"
+      "html" : "<p a='b'></p>",
+      "optional" : true
     },
 
-    "an interpolated attribute" : {
+    "Ruby-style interpolated attribute" : {
       "haml" : "%p{:a =>\"#{var}\"}",
       "html" : "<p a='value'></p>",
+      "optional" : true,
       "locals" : {
         "var" : "value"
       }
     },
 
-    "multiple attributes" : {
+    "Ruby-style multiple attributes" : {
       "haml" : "%p{ :a => 'b', 'c' => 'd' }",
-      "html" : "<p a='b' c='d'></p>"
+      "html" : "<p a='b' c='d'></p>",
+      "optional" : true
     },
 
-    "attributes separated with newlines" : {
+    "Ruby-style attributes separated with newlines" : {
       "haml" : "%p{ :a => 'b',\n  'c' => 'd' }",
-      "html" : "<p a='b' c='d'></p>"
+      "html" : "<p a='b' c='d'></p>",
+      "optional" : true
     },
 
-    "'class' as an attribute" : {
+    "Ruby-style 'class' as an attribute" : {
       "haml" : "%p{:class => 'class1'}",
-      "html" : "<p class='class1'></p>"
+      "html" : "<p class='class1'></p>",
+      "optional" : true
     },
 
-    "a tag with a CSS class and 'class' as an attribute" : {
+    "Ruby-style tag with a CSS class and 'class' as an attribute" : {
       "haml" : "%p.class2{:class => 'class1'}",
-      "html" : "<p class='class1 class2'></p>"
+      "html" : "<p class='class1 class2'></p>",
+      "optional" : true
     },
 
-    "a tag with 'id' as an attribute" : {
+    "Ruby-style tag with 'id' as an attribute" : {
       "haml" : "%p{:id => '1'}",
-      "html" : "<p id='1'></p>"
+      "html" : "<p id='1'></p>",
+      "optional" : true
     },
 
-    "a tag with a CSS id and 'id' as an attribute" : {
+    "Ruby-style tag with a CSS id and 'id' as an attribute" : {
       "haml" : "%p#id{:id => '1'}",
-      "html" : "<p id='id_1'></p>"
+      "html" : "<p id='id_1'></p>",
+      "optional" : true
     },
 
-    "a tag with a CSS id and a numeric 'id' as an attribute" : {
+    "Ruby-style tag with a CSS id and a numeric 'id' as an attribute" : {
       "haml" : "%p#id{:id => 1}",
-      "html" : "<p id='id_1'></p>"
+      "html" : "<p id='id_1'></p>",
+      "optional" : true
     },
 
-    "a tag with a variable attribute" : {
+    "Ruby-style tag with a variable attribute" : {
       "haml" : "%p{:class => var}",
       "html" : "<p class='hello'></p>",
+      "optional" : true,
       "locals" : {
         "var" : "hello"
       }
     },
 
-    "a tag with a CSS class and 'class' as a variable attribute" : {
+    "Ruby-style tag with a CSS class and 'class' as a variable attribute" : {
       "haml" : ".hello{:class => var}",
       "html" : "<div class='hello world'></div>",
+      "optional" : true,
       "locals" : {
         "var" : "world"
       }
     },
 
-    "a tag multiple CSS classes (sorted correctly)" : {
+    "Ruby-style tag multiple CSS classes (sorted correctly)" : {
       "haml" : ".z{:class => var}",
       "html" : "<div class='a z'></div>",
+      "optional" : true,
       "locals" : {
         "var" : "a"
       }
     }
-
   },
 
   "silent comments" : {
 
-    "an inline comment" : {
+    "an inline silent comment" : {
       "haml" : "-# hello",
       "html" : ""
     },
 
-    "a nested comment" : {
+    "a nested silent comment" : {
       "haml" : "-#\n  hello",
       "html" : ""
-    }
+    },
+
+    "a multiply nested silent comment" : {
+      "haml" : "-#\n  %div\n    foo",
+      "html" : ""
+    },
 
+    "a multiply nested silent comment with inconsistent indents" : {
+      "haml" : "-#\n  %div\n      foo",
+      "html" : ""
+    }
   },
 
   "markup comments" : {
 
-    "an inline comment" : {
+    "an inline markup comment" : {
       "haml" : "/ comment",
       "html" : "<!-- comment -->"
     },
 
-    "a nested comment" : {
+    "a nested markup comment" : {
       "haml" : "/\n  comment\n  comment2",
       "html" : "<!--\n  comment\n  comment2\n-->"
     }
@@ -447,6 +478,11 @@
       "html" : "hello\n<p></p>"
     },
 
+    "content in a 'css' filter" : {
+      "haml" : ":css\n  hello\n\n%p",
+      "html" : "<style type='text/css'>\n  /*<![CDATA[*/\n    hello\n  /*]]>*/\n</style>\n<p></p>"
+    },
+
     "content in a 'javascript' filter" : {
       "haml" : ":javascript\n  a();\n%p",
       "html" : "<script type='text/javascript'>\n  //<![CDATA[\n    a();\n  //]]>\n</script>\n<p></p>"
@@ -454,11 +490,12 @@
 
   },
 
-  "interpolation": {
+  "Ruby-style interpolation": {
 
     "interpolation inside inline content" : {
       "haml" : "%p #{var}",
       "html" : "<p>value</p>",
+      "optional" : true,
       "locals" : {
         "var" : "value"
       }
@@ -466,12 +503,17 @@
 
     "no interpolation when escaped" : {
       "haml" : "%p \\#{var}",
-      "html" : "<p>#{var}</p>"
+      "html" : "<p>#{var}</p>",
+      "optional" : true,
+      "locals" : {
+        "var" : "value"
+      }
     },
 
     "interpolation when the escape character is escaped" : {
       "haml" : "%p \\\\#{var}",
       "html" : "<p>\\value</p>",
+      "optional" : true,
       "locals" : {
         "var" : "value"
       }
@@ -480,11 +522,11 @@
     "interpolation inside filtered content" : {
       "haml" : ":plain\n  #{var} interpolated: #{var}",
       "html" : "value interpolated: value",
+      "optional" : true,
       "locals" : {
         "var" : "value"
       }
     }
-
   },
 
   "HTML escaping" : {
@@ -512,7 +554,7 @@
 
   },
 
-  "Boolean attributes" : {
+  "boolean attributes" : {
 
     "boolean attribute with XHTML" : {
       "haml" : "%input(checked=true)",
@@ -529,6 +571,42 @@
         "format" : "html5"
       }
     }
-  }
+  },
+
+  "whitespace preservation" : {
+
+    "following the '~' operator" : {
+      "haml"     : "~ \"Foo\\n<pre>Bar\\nBaz</pre>\"",
+      "html"     : "Foo\n<pre>Bar&#x000A;Baz</pre>",
+      "optional" : true
+    },
 
+    "inside a textarea tag" : {
+      "haml" : "%textarea\n  hello\n  hello",
+      "html" : "<textarea>hello\nhello</textarea>"
+    },
+
+    "inside a pre tag" : {
+      "haml" : "%pre\n  hello\n  hello",
+      "html" : "<pre>hello\nhello</pre>"
+    }
+  },
+
+  "whitespace removal" : {
+
+    "a tag with '>' appended and inline content" : {
+      "haml" : "%li hello\n%li> world\n%li again",
+      "html" : "<li>hello</li><li>world</li><li>again</li>"
+    },
+
+    "a tag with '>' appended and nested content" : {
+      "haml" : "%li hello\n%li>\n  world\n%li again",
+      "html" : "<li>hello</li><li>\n  world\n</li><li>again</li>"
+    },
+
+    "a tag with '<' appended" : {
+      "haml" : "%p<\n  hello\n  world",
+      "html" : "<p>hello\nworld</p>"
+    }
+  }
 }

data/test/{haml/helper_test.rb → helper_test.rb}

@@ -1,5 +1,4 @@
-#!/usr/bin/env ruby
-require File.dirname(__FILE__) + '/../test_helper'
+require 'test_helper'
 
 class ActionView::Base
   def nested_tag
@@ -17,7 +16,7 @@ module Haml::Helpers
   end
 end
 
-class HelperTest < Test::Unit::TestCase
+class HelperTest < MiniTest::Unit::TestCase
   Post = Struct.new('Post', :body, :error_field, :errors)
   class PostErrors
     def on(name)
@@ -30,7 +29,7 @@ class HelperTest < Test::Unit::TestCase
       on(name) || []
     end
   end
-  
+
   def setup
     @base = ActionView::Base.new
     @base.controller = ActionController::Base.new
@@ -68,6 +67,10 @@ class HelperTest < Test::Unit::TestCase
     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",
       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",
+      render("= list_of(['Fee', 'Fi', 'Fo', 'Fum'], {:c => 3}) do |title|\n  %h1= title\n  %p A word!"))
   end
 
   def test_buffer_access
@@ -110,40 +113,53 @@ HAML
       ActionView::Base.new.render(:inline => "<%= concat('foo') %>")
     rescue ArgumentError, NameError
       proper_behavior = true
-    end    
+    end
     assert(proper_behavior)
   end
-  
+
   def test_action_view_included
     assert(Haml::Helpers.action_view?)
   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 #{rails_form_attr}action="foo" method="post">#{rails_form_opener}
+<form accept-charset="UTF-8" action="foo" method="post">#{rails_form_opener}
   <p>bar</p>
   <strong>baz</strong>
 </form>
 HTML
-#{rails_block_helper_char} form_tag 'foo' do
+= form_tag 'foo' do
   %p bar
   %strong baz
 HAML
   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))
+  if Rails.version >= "3.2.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))
+
+      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))
 
-    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
+  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))
+
+      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))    
+      assert_equal(%(<pre>Foo bar&#x000A;   baz</pre>\n),
+                   render('= content_tag "pre", "Foo bar\n   baz"', :action_view))
+    end
   end
-  
+
   def test_capture_haml
     assert_equal(<<HTML, render(<<HAML))
 "<p>13</p>\\n"
@@ -151,7 +167,7 @@ HTML
 - (foo = capture_haml(13) do |a|
   %p= a
 - end; nil)
-= foo.dump
+= foo.inspect
 HAML
   end
 
@@ -161,7 +177,7 @@ HAML
 <strong>bar</strong>
 </div>
 HTML
-#{rails_block_helper_char} content_tag :div do
+= content_tag :div do
   %p bar
   %strong bar
 HAML
@@ -169,13 +185,12 @@ HAML
 
   def test_content_tag_error_wrapping
     def @base.protect_against_forgery?; false; end
-    error_class = Haml::Util.ap_geq_3? ? "field_with_errors" : "fieldWithErrors"
     assert_equal(<<HTML, render(<<HAML, :action_view))
-<form #{rails_form_attr}action="" method="post">#{rails_form_opener}
-  <div class="#{error_class}"><label for="post_error_field">Error field</label></div>
+<form accept-charset="UTF-8" action="" method="post">#{rails_form_opener}
+  <div class="field_with_errors"><label for="post_error_field">Error field</label></div>
 </form>
 HTML
-#{rails_block_helper_char} form_for #{form_for_calling_convention('post')}, :url => '' do |f|
+= form_for @post, :as => :post, :html => {:class => nil, :id => nil}, :url => '' do |f|
   = f.label 'error_field'
 HAML
   end
@@ -183,9 +198,9 @@ 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 #{rails_form_attr}action="/foo" method="post">#{rails_form_opener}bar</form>
+<form accept-charset="UTF-8" action="/foo" method="post">#{rails_form_opener}bar</form>
 HTML
-#{rails_block_helper_char} wacky_form
+= wacky_form
 HAML
   end
 
@@ -229,8 +244,8 @@ HAML
     assert_equal("<p class='foo bar' id='some_id'></p>\n", render("- haml_tag 'p.foo.bar#some_id'"))
   end
 
-  def test_haml_tag_name_and_attribute_classes_merging
-    assert_equal("<p class='foo bar' id='some_id'></p>\n", render("- haml_tag 'p#some_id.foo', :class => 'bar'"))
+  def test_haml_tag_name_and_attribute_classes_merging_with_id
+    assert_equal("<p class='bar foo' id='some_id'></p>\n", render("- haml_tag 'p#some_id.foo', :class => 'bar'"))
   end
 
   def test_haml_tag_name_and_attribute_classes_merging
@@ -273,19 +288,19 @@ HAML
   end
 
   def test_haml_tag_raises_error_for_multiple_content
-    assert_raise(Haml::Error) { render("- haml_tag :p, 'foo' do\n  bar") }
+    assert_raises(Haml::Error) { render("- haml_tag :p, 'foo' do\n  bar") }
   end
 
   def test_haml_tag_flags
     assert_equal("<p />\n", render("- haml_tag :p, :/"))
     assert_equal("<p>kumquat</p>\n", render("- haml_tag :p, :< do\n  kumquat"))
 
-    assert_raise(Haml::Error) { render("- haml_tag :p, 'foo', :/") }
-    assert_raise(Haml::Error) { render("- haml_tag :p, :/ do\n  foo") }
+    assert_raises(Haml::Error) { render("- haml_tag :p, 'foo', :/") }
+    assert_raises(Haml::Error) { render("- haml_tag :p, :/ do\n  foo") }
   end
 
   def test_haml_tag_error_return
-    assert_raise(Haml::Error) { render("= haml_tag :p") }
+    assert_raises(Haml::Error) { render("= haml_tag :p") }
   end
 
   def test_haml_tag_with_multiline_string
@@ -341,12 +356,11 @@ HAML
   end
 
   def test_indented_capture
-    prior = Haml::Util.ap_geq_3? ? "" : "  \n"
-    assert_equal("#{prior}  Foo\n  ", @base.render(:inline => "  <% res = capture do %>\n  Foo\n  <% end %><%= res %>"))
+    assert_equal("  Foo\n  ", @base.render(:inline => "  <% res = capture do %>\n  Foo\n  <% end %><%= res %>"))
   end
 
   def test_capture_deals_properly_with_collections
-    Haml::Helpers.module_eval do 
+    Haml::Helpers.module_eval do
       def trc(collection, &block)
         collection.each do |record|
           haml_concat capture_haml(record, &block)
@@ -401,7 +415,7 @@ HAML
   end
 
   def test_error_return
-    assert_raise(Haml::Error, <<MESSAGE) {render("= haml_concat 'foo'")}
+    assert_raises(Haml::Error, <<MESSAGE) {render("= haml_concat 'foo'")}
 haml_concat outputs directly to the Haml template.
 Disregard its return value and use the - operator,
 or use capture_haml to get the value as a String.
@@ -419,7 +433,7 @@ MESSAGE
     render("- something_that_uses_haml_concat")
     assert false, "Expected Haml::Error"
   rescue Haml::Error => e
-    assert_equal 16, e.backtrace[0].scan(/:(\d+)/).first.first.to_i
+    assert_equal 15, e.backtrace[0].scan(/:(\d+)/).first.first.to_i
   end
 
   class ActsLikeTag