RubyGems - haml - Versions diffs - 4.0.6 → 5.2.0 - Mend

haml 4.0.6 → 5.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (118) hide show

checksums.yaml +5 -5
data/.gitignore +19 -0
data/.gitmodules +3 -0
data/.travis.yml +72 -0
data/.yardopts +2 -3
data/CHANGELOG.md +138 -4
data/FAQ.md +4 -14
data/Gemfile +16 -0
data/MIT-LICENSE +2 -2
data/README.md +79 -42
data/REFERENCE.md +142 -67
data/Rakefile +44 -63
data/TODO +24 -0
data/benchmark.rb +70 -0
data/haml.gemspec +45 -0
data/lib/haml.rb +2 -0
data/lib/haml/.gitattributes +1 -0
data/lib/haml/attribute_builder.rb +164 -0
data/lib/haml/attribute_compiler.rb +235 -0
data/lib/haml/attribute_parser.rb +150 -0
data/lib/haml/buffer.rb +29 -136
data/lib/haml/compiler.rb +110 -320
data/lib/haml/engine.rb +34 -41
data/lib/haml/error.rb +28 -24
data/lib/haml/escapable.rb +77 -0
data/lib/haml/exec.rb +38 -20
data/lib/haml/filters.rb +22 -27
data/lib/haml/generator.rb +42 -0
data/lib/haml/helpers.rb +134 -89
data/lib/haml/helpers/action_view_extensions.rb +4 -2
data/lib/haml/helpers/action_view_mods.rb +45 -60
data/lib/haml/helpers/action_view_xss_mods.rb +2 -0
data/lib/haml/helpers/safe_erubi_template.rb +20 -0
data/lib/haml/helpers/safe_erubis_template.rb +5 -1
data/lib/haml/helpers/xss_mods.rb +23 -13
data/lib/haml/options.rb +63 -69
data/lib/haml/parser.rb +292 -228
data/lib/haml/plugin.rb +37 -0
data/lib/haml/railtie.rb +38 -12
data/lib/haml/sass_rails_filter.rb +18 -4
data/lib/haml/template.rb +13 -6
data/lib/haml/template/options.rb +13 -2
data/lib/haml/temple_engine.rb +123 -0
data/lib/haml/temple_line_counter.rb +30 -0
data/lib/haml/util.rb +83 -202
data/lib/haml/version.rb +3 -1
data/yard/default/.gitignore +1 -0
data/yard/default/fulldoc/html/css/common.sass +15 -0
data/yard/default/layout/html/footer.erb +12 -0
metadata +73 -108
data/lib/haml/template/plugin.rb +0 -41
data/test/engine_test.rb +0 -2013
data/test/erb/_av_partial_1.erb +0 -12
data/test/erb/_av_partial_2.erb +0 -8
data/test/erb/action_view.erb +0 -62
data/test/erb/standard.erb +0 -55
data/test/filters_test.rb +0 -254
data/test/gemfiles/Gemfile.rails-3.0.x +0 -5
data/test/gemfiles/Gemfile.rails-3.1.x +0 -6
data/test/gemfiles/Gemfile.rails-3.2.x +0 -5
data/test/gemfiles/Gemfile.rails-4.0.x +0 -5
data/test/helper_test.rb +0 -583
data/test/markaby/standard.mab +0 -52
data/test/mocks/article.rb +0 -6
data/test/parser_test.rb +0 -105
data/test/results/content_for_layout.xhtml +0 -12
data/test/results/eval_suppressed.xhtml +0 -9
data/test/results/helpers.xhtml +0 -70
data/test/results/helpful.xhtml +0 -10
data/test/results/just_stuff.xhtml +0 -70
data/test/results/list.xhtml +0 -12
data/test/results/nuke_inner_whitespace.xhtml +0 -40
data/test/results/nuke_outer_whitespace.xhtml +0 -148
data/test/results/original_engine.xhtml +0 -20
data/test/results/partial_layout.xhtml +0 -5
data/test/results/partial_layout_erb.xhtml +0 -5
data/test/results/partials.xhtml +0 -21
data/test/results/render_layout.xhtml +0 -3
data/test/results/silent_script.xhtml +0 -74
data/test/results/standard.xhtml +0 -162
data/test/results/tag_parsing.xhtml +0 -23
data/test/results/very_basic.xhtml +0 -5
data/test/results/whitespace_handling.xhtml +0 -90
data/test/template_test.rb +0 -354
data/test/templates/_av_partial_1.haml +0 -9
data/test/templates/_av_partial_1_ugly.haml +0 -9
data/test/templates/_av_partial_2.haml +0 -5
data/test/templates/_av_partial_2_ugly.haml +0 -5
data/test/templates/_layout.erb +0 -3
data/test/templates/_layout_for_partial.haml +0 -3
data/test/templates/_partial.haml +0 -8
data/test/templates/_text_area.haml +0 -3
data/test/templates/_text_area_helper.html.haml +0 -4
data/test/templates/action_view.haml +0 -47
data/test/templates/action_view_ugly.haml +0 -47
data/test/templates/breakage.haml +0 -8
data/test/templates/content_for_layout.haml +0 -8
data/test/templates/eval_suppressed.haml +0 -11
data/test/templates/helpers.haml +0 -55
data/test/templates/helpful.haml +0 -11
data/test/templates/just_stuff.haml +0 -85
data/test/templates/list.haml +0 -12
data/test/templates/nuke_inner_whitespace.haml +0 -32
data/test/templates/nuke_outer_whitespace.haml +0 -144
data/test/templates/original_engine.haml +0 -17
data/test/templates/partial_layout.haml +0 -3
data/test/templates/partial_layout_erb.erb +0 -4
data/test/templates/partialize.haml +0 -1
data/test/templates/partials.haml +0 -12
data/test/templates/render_layout.haml +0 -2
data/test/templates/silent_script.haml +0 -45
data/test/templates/standard.haml +0 -43
data/test/templates/standard_ugly.haml +0 -43
data/test/templates/tag_parsing.haml +0 -21
data/test/templates/very_basic.haml +0 -4
data/test/templates/whitespace_handling.haml +0 -87
data/test/test_helper.rb +0 -81
data/test/util_test.rb +0 -63

data/test/erb/_av_partial_1.erb DELETED

@@ -1,12 +0,0 @@
-<h2>This is a pretty complicated partial</h2>
-<div class="partial">
-  <p>It has several nested partials,</p>
-  <ul>
-    <% 5.times do %>
-      <li>
-        <strong>Partial:</strong>
-        <% @nesting = 5 %>
-        <%= render :partial => 'erb/av_partial_2' %>
-    <% end %>
-  </ul>
-</div>

data/test/erb/_av_partial_2.erb DELETED

@@ -1,8 +0,0 @@
-<% @nesting -= 1 %>
-<div class="partial" level="<%= @nesting %>">
-  <h3>This is a crazy deep-nested partial.</h3>
-  <p>Nesting level <%= @nesting %></p>
-  <% if @nesting > 0 %>
-    <%= render :partial => 'erb/av_partial_2' %>
-  <% end %>
-</div>

data/test/erb/action_view.erb DELETED

@@ -1,62 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns='http://www.w3.org/1999/xhtml' xml:lang='en-US'>
-  <head>
-    <title>Hampton Catlin Is Totally Awesome</title>
-    <meta content='text/html; charset=utf-8' http-equiv='Content-Type' />
-  </head>
-  <body>
-    <h1>
-      This is very much like the standard template,
-      except that it has some ActionView-specific stuff.
-      It's only used for benchmarking.
-    </h1>
-    <div class="crazy_partials">
-      <%= render :partial => 'erb/av_partial_1' %>
-    </div>
-    <!-- You're In my house now! -->
-    <div class='header'>
-      Yes, ladies and gentileman. He is just that egotistical.
-      Fantastic! This should be multi-line output
-      The question is if this would translate! Ahah!
-      <%= 1 + 9 + 8 + 2 %>
-      <%# numbers should work and this should be ignored %>
-    </div>
-    <% 120.times do |number| -%>
-      <%= number %>
-    <% end -%>
-    <div id='body'><%= " Quotes should be loved! Just like people!" %></div>
-    Wow.
-    <p>
-      <%= "Holy cow        " +
-          "multiline       " +
-          "tags!           " +
-          "A pipe (|) even!"  %>
-      <%= [1, 2, 3].collect { |n| "PipesIgnored|" } %>
-      <%= [1, 2, 3].collect { |n|
-          n.to_s
-        }.join("|") %>
-    </p>
-    <div class='silent'>
-      <% foo = String.new
-         foo << "this"
-         foo << " shouldn't"
-         foo << " evaluate" %>
-      <%= foo + "but now it should!" %>
-      <%# Woah crap a comment! %>
-    </div>
-    <ul class='really cool'>
-      <% ('a'..'f').each do |a|%>
-      <li><%= a %>
-      <% end %>
-    <div class='of_divs_with_underscore' id='combo'><%= @should_eval = "with this text" %></div>
-    <%= [ 104, 101, 108, 108, 111 ].map do |byte|
-      byte.chr
-    end %>
-    <div class='footer'>
-      <strong class='shout'>
-        <%= "This is a really long ruby quote. It should be loved and wrapped because its more than 50 characters. This value may change in the future and this test may look stupid.\n" +
-"        So, I'm just making it *really* long. God, I hope this works" %>
-      </strong>
-    </div>
-  </body>
-</html>

data/test/erb/standard.erb DELETED

@@ -1,55 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns='http://www.w3.org/1999/xhtml' xml:lang='en-US' lang='en-US'>
-  <head>
-    <title>Hampton Catlin Is Totally Awesome</title>
-    <meta content='text/html; charset=utf-8' http-equiv='Content-Type' />
-  </head>
-  <body>
-    <!-- You're In my house now! -->
-    <div class='header'>
-      Yes, ladies and gentileman. He is just that egotistical.
-      Fantastic! This should be multi-line output
-      The question is if this would translate! Ahah!
-      <%= 1 + 9 + 8 + 2 %>
-      <%# numbers should work and this should be ignored %>
-    </div>
-    <% 120.times do |number| -%>
-      <%= number %>
-    <% end -%>
-    <div id='body'><%= " Quotes should be loved! Just like people!" %></div>
-    Wow.
-    <p code="<%= 1 + 2 %>">
-      <%= "Holy cow        " +
-          "multiline       " +
-          "tags!           " +
-          "A pipe (|) even!"  %>
-      <%= [1, 2, 3].collect { |n| "PipesIgnored|" }.join %>
-      <%= [1, 2, 3].collect { |n|
-          n.to_s
-        }.join("|") %>
-    </p>
-    <% bar = 17 %>
-    <div class='silent' foo="<%= bar %>">
-      <% foo = String.new
-         foo << "this"
-         foo << " shouldn't"
-         foo << " evaluate" %>
-      <%= foo + "but now it should!" %>
-      <%# Woah crap a comment! %>
-    </div>
-    <ul class='really cool'>
-      <% ('a'..'f').each do |a|%>
-      <li><%= a %></li>
-      <% end %>
-    <div class='of_divs_with_underscore' id='combo'><%= @should_eval = "with this text" %></div>
-    <%= "foo".each_line do |line|
-      nil
-    end %>
-    <div class='footer'>
-      <strong class='shout'>
-        <%= "This is a really long ruby quote. It should be loved and wrapped because its more than 50 characters. This value may change in the future and this test may look stupid.\n" +
-"        So, I'm just making it *really* long. God, I hope this works" %>
-      </strong>
-    </div>
-  </body>
-</html>

data/test/filters_test.rb DELETED

@@ -1,254 +0,0 @@
-require 'test_helper'
-class FiltersTest < MiniTest::Unit::TestCase
-  test "should be registered as filters when including Haml::Filters::Base" do
-    begin
-      refute Haml::Filters.defined.has_key? "bar"
-      Module.new {def self.name; "Foo::Bar"; end; include Haml::Filters::Base}
-      assert Haml::Filters.defined.has_key? "bar"
-    ensure
-      Haml::Filters.remove_filter "Bar"
-    end
-  end
-  test "should raise error when attempting to register a defined Tilt filter" do
-    begin
-      assert_raises RuntimeError do
-        2.times do
-          Haml::Filters.register_tilt_filter "Foo"
-        end
-      end
-    ensure
-      Haml::Filters.remove_filter "Foo"
-    end
-  end
-  test "should raise error when a Tilt filters dependencies are unavailable for extension" do
-    begin
-      assert_raises Haml::Error do
-        Haml::Filters.register_tilt_filter "Textile"
-        Haml::Filters.defined["textile"].template_class
-      end
-    ensure
-      Haml::Filters.remove_filter "Textile"
-    end
-  end
-  test "should raise error when a Tilt filters dependencies are unavailable for filter without extension" do
-    begin
-      assert_raises Haml::Error do
-        Haml::Filters.register_tilt_filter "Maruku"
-        Haml::Filters.defined["maruku"].template_class
-      end
-    ensure
-      Haml::Filters.remove_filter "Maruku"
-    end
-  end
-  test "should raise informative error about Maruku being moved to haml-contrib" do
-    begin
-      render(":maruku\n  # foo")
-      flunk("Should have raised error with message about the haml-contrib gem.")
-    rescue Haml::Error => e
-      assert_equal e.message, Haml::Error.message(:install_haml_contrib, "maruku")
-    end
-  end
-  test "should raise informative error about Textile being moved to haml-contrib" do
-    begin
-      render(":textile\n  h1. foo")
-      flunk("Should have raised error with message about the haml-contrib gem.")
-    rescue Haml::Error => e
-      assert_equal e.message, Haml::Error.message(:install_haml_contrib, "textile")
-    end
-  end
-  test "should respect escaped newlines and interpolation" do
-    html = "\\n\n"
-    haml = ":plain\n  \\n\#{""}"
-    assert_equal(html, render(haml))
-  end
-  test "should process an filter with no content" do
-    assert_equal("\n", render(':plain'))
-  end
-  test "should be compatible with ugly mode" do
-    expectation = "foo\n"
-    assert_equal(expectation, render(":plain\n  foo", :ugly => true))
-  end
-  test "should pass options to Tilt filters that precompile" do
-    haml  = ":erb\n  <%= 'foo' %>"
-    refute_match('TEST_VAR', Haml::Engine.new(haml).compiler.precompiled)
-    Haml::Filters::Erb.options = {:outvar => 'TEST_VAR'}
-    assert_match('TEST_VAR', Haml::Engine.new(haml).compiler.precompiled)
-  end
-  test "should pass options to Tilt filters that don't precompile" do
-    begin
-      filter = Class.new(Tilt::Template) do
-        def self.name
-          "Foo"
-        end
-        def prepare
-          @engine = {:data => data, :options => options}
-        end
-        def evaluate(scope, locals, &block)
-          @output = @engine[:options].to_a.join
-        end
-      end
-      Haml::Filters.register_tilt_filter "Foo", :template_class => filter
-      Haml::Filters::Foo.options[:foo] = "bar"
-      haml = ":foo"
-      assert_equal "foobar\n", render(haml)
-    ensure
-      Haml::Filters.remove_filter "Foo"
-    end
-  end
-end
-class ErbFilterTest < MiniTest::Unit::TestCase
-  test "multiline expressions should work" do
-    html = "foobarbaz\n"
-    haml = %Q{:erb\n  <%= "foo" +\n      "bar" +\n      "baz" %>}
-    assert_equal(html, render(haml))
-  end
-  test "should evaluate in the same context as Haml" do
-    haml  = ":erb\n  <%= foo %>"
-    html  = "bar\n"
-    scope = Object.new.instance_eval {foo = "bar"; nil if foo; binding}
-    assert_equal(html, render(haml, :scope => scope))
-  end
-  test "should use Rails's XSS safety features" do
-    assert_equal("&lt;img&gt;\n", render(":erb\n  <%= '<img>' %>"))
-    assert_equal("<img>\n", render(":erb\n  <%= '<img>'.html_safe %>"))
-  end
-end
-class JavascriptFilterTest < MiniTest::Unit::TestCase
-  test "should interpolate" do
-    scope = Object.new.instance_eval {foo = "bar"; nil if foo; binding}
-    haml  = ":javascript\n  \#{foo}"
-    html  = render(haml, :scope => scope)
-    assert_match(/bar/, html)
-  end
-  test "should never HTML-escape ampersands" do
-    html = "<script>\n  & < > &\n</script>\n"
-    haml = %Q{:javascript\n  & < > \#{"&"}}
-    assert_equal(html, render(haml, :escape_html => true))
-  end
-  test "should not include type in HTML 5 output" do
-    html = "<script>\n  foo bar\n</script>\n"
-    haml = ":javascript\n  foo bar"
-    assert_equal(html, render(haml, :format => :html5))
-  end
-  test "should always include CDATA when format is xhtml" do
-    html = "<script type='text/javascript'>\n  //<![CDATA[\n    foo bar\n  //]]>\n</script>\n"
-    haml = ":javascript\n  foo bar"
-    assert_equal(html, render(haml, :format => :xhtml, :cdata => false))
-  end
-  test "should omit CDATA when cdata option is false" do
-    html = "<script>\n  foo bar\n</script>\n"
-    haml = ":javascript\n  foo bar"
-    assert_equal(html, render(haml, :format => :html5, :cdata => false))
-  end
-  test "should include CDATA when cdata option is true" do
-    html = "<script>\n  //<![CDATA[\n    foo bar\n  //]]>\n</script>\n"
-    haml = ":javascript\n  foo bar"
-    assert_equal(html, render(haml, :format => :html5, :cdata => true))
-  end
-  test "should default to no CDATA when format is html5" do
-    haml = ":javascript\n  foo bar"
-    out = render(haml, :format => :html5)
-    refute_match('//<![CDATA[', out)
-    refute_match('//]]>', out)
-  end
-end
-class CSSFilterTest < MiniTest::Unit::TestCase
-  test "should wrap output in CDATA and a CSS tag when output is XHTML" do
-    html = "<style type='text/css'>\n  /*<![CDATA[*/\n    foo\n  /*]]>*/\n</style>\n"
-    haml = ":css\n  foo"
-    assert_equal(html, render(haml, :format => :xhtml))
-  end
-  test "should not include type in HTML 5 output" do
-    html = "<style>\n  foo bar\n</style>\n"
-    haml = ":css\n  foo bar"
-    assert_equal(html, render(haml, :format => :html5))
-  end
-  test "should always include CDATA when format is xhtml" do
-    html = "<style type='text/css'>\n  /*<![CDATA[*/\n    foo bar\n  /*]]>*/\n</style>\n"
-    haml = ":css\n  foo bar"
-    assert_equal(html, render(haml, :format => :xhtml, :cdata => false))
-  end
-  test "should omit CDATA when cdata option is false" do
-    html = "<style>\n  foo bar\n</style>\n"
-    haml = ":css\n  foo bar"
-    assert_equal(html, render(haml, :format => :html5, :cdata => false))
-  end
-  test "should include CDATA when cdata option is true" do
-    html = "<style>\n  /*<![CDATA[*/\n    foo bar\n  /*]]>*/\n</style>\n"
-    haml = ":css\n  foo bar"
-    assert_equal(html, render(haml, :format => :html5, :cdata => true))
-  end
-  test "should default to no CDATA when format is html5" do
-    haml = ":css\n  foo bar"
-    out = render(haml, :format => :html5)
-    refute_match('<![CDATA[', out)
-    refute_match(']]>', out)
-  end
-end
-class CDATAFilterTest < MiniTest::Unit::TestCase
-  test "should wrap output in CDATA tag" do
-    html = "<![CDATA[\n    foo\n]]>\n"
-    haml = ":cdata\n  foo"
-    assert_equal(html, render(haml))
-  end
-end
-class EscapedFilterTest < MiniTest::Unit::TestCase
-  test "should escape ampersands" do
-    html = "&amp;\n"
-    haml = ":escaped\n  &"
-    assert_equal(html, render(haml))
-  end
-end
-class RubyFilterTest < MiniTest::Unit::TestCase
-  test "can write to haml_io" do
-    haml = ":ruby\n  haml_io.puts 'hello'\n"
-    html = "hello\n"
-    assert_equal(html, render(haml))
-  end
-  test "haml_io appends to output" do
-    haml = "hello\n:ruby\n  haml_io.puts 'hello'\n"
-    html = "hello\nhello\n"
-    assert_equal(html, render(haml))
-  end
-  test "can create local variables" do
-    haml = ":ruby\n  a = 7\n=a"
-    html = "7\n"
-    assert_equal(html, render(haml))
-  end
-end

data/test/gemfiles/Gemfile.rails-3.0.x DELETED

@@ -1,5 +0,0 @@
-source "http://rubygems.org"
-gem 'rails', '>= 3.0.0', '<  3.1.0'
-gemspec :path => "../.."

data/test/gemfiles/Gemfile.rails-3.1.x DELETED

@@ -1,6 +0,0 @@
-source "http://rubygems.org"
-gem 'rails', '>= 3.1.0', '< 3.2.0'
-gemspec :path => "../.."

data/test/gemfiles/Gemfile.rails-3.2.x DELETED

@@ -1,5 +0,0 @@
-source "http://rubygems.org"
-gem 'rails', '>= 3.2.0', '< 3.3.0'
-gemspec :path => "../.."

data/test/gemfiles/Gemfile.rails-4.0.x DELETED

@@ -1,5 +0,0 @@
-source "http://rubygems.org"
-gem 'bundler', '~> 1.3.0'
-gem 'rails', '~> 4.0.0.rc1'
-gemspec :path => '../..'

data/test/helper_test.rb DELETED

@@ -1,583 +0,0 @@
-require 'test_helper'
-class ActionView::Base
-  def nested_tag
-    content_tag(:span) {content_tag(:div) {"something"}}
-  end
-  def wacky_form
-    form_tag("/foo") {"bar"}
-  end
-end
-module Haml::Helpers
-  def something_that_uses_haml_concat
-    haml_concat('foo').to_s
-  end
-  def render_something_with_haml_concat
-    haml_concat "<p>"
-  end
-  def render_something_with_haml_tag_and_concat
-    haml_tag 'p' do
-      haml_concat '<foo>'
-    end
-  end
-end
-class HelperTest < MiniTest::Unit::TestCase
-  Post = Struct.new('Post', :body, :error_field, :errors)
-  class PostErrors
-    def on(name)
-      return unless name == 'error_field'
-      ["Really bad error"]
-    end
-    alias_method :full_messages, :on
-    def [](name)
-      on(name) || []
-    end
-  end
-  def setup
-    @base = ActionView::Base.new
-    @base.controller = ActionController::Base.new
-    @base.view_paths << File.expand_path("../templates", __FILE__)
-    if defined?(ActionController::Response)
-      # This is needed for >=3.0.0
-      @base.controller.response = ActionController::Response.new
-    end
-    @base.instance_variable_set('@post', Post.new("Foo bar\nbaz", nil, PostErrors.new))
-  end
-  def render(text, options = {})
-    return @base.render :inline => text, :type => :haml if options == :action_view
-    super
-  end
-  def test_rendering_with_escapes
-    output = render(<<-HAML, :action_view)
-- render_something_with_haml_concat
-- render_something_with_haml_tag_and_concat
-- render_something_with_haml_concat
-HAML
-    assert_equal("&lt;p&gt;\n<p>\n  <foo>\n</p>\n&lt;p&gt;\n", output)
-  end
-  def test_flatten
-    assert_equal("FooBar", Haml::Helpers.flatten("FooBar"))
-    assert_equal("FooBar", Haml::Helpers.flatten("Foo\rBar"))
-    assert_equal("Foo&#x000A;Bar", Haml::Helpers.flatten("Foo\nBar"))
-    assert_equal("Hello&#x000A;World!&#x000A;YOU ARE FLAT?&#x000A;OMGZ!",
-      Haml::Helpers.flatten("Hello\nWorld!\nYOU ARE \rFLAT?\n\rOMGZ!"))
-  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",
-      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
-    assert(render("= buffer") =~ /#<Haml::Buffer:0x[a-z0-9]+>/)
-    assert_equal(render("= (buffer == _hamlout)"), "true\n")
-  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"))
-  end
-  def test_with_tabs
-    assert_equal(<<HTML, render(<<HAML))
-Foo
-    Bar
-    Baz
-Baz
-HTML
-Foo
-- with_tabs 2 do
-  = "Bar\\nBaz"
-Baz
-HAML
-  end
-  def test_helpers_dont_leak
-    # Haml helpers shouldn't be accessible from ERB
-    render("foo")
-    proper_behavior = false
-    begin
-      ActionView::Base.new.render(:inline => "<%= flatten('Foo\\nBar') %>")
-    rescue NoMethodError, Haml::Util.av_template_class(:Error)
-      proper_behavior = true
-    end
-    assert(proper_behavior)
-    begin
-      ActionView::Base.new.render(:inline => "<%= concat('foo') %>")
-    rescue ArgumentError, NameError
-      proper_behavior = true
-    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
-    rendered = render(<<HAML, :action_view)
-= form_tag 'foo' do
-  %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
-  def test_pre
-    assert_equal(%(<pre>Foo bar&#x000A;   baz</pre>\n),
-                 render('= content_tag "pre", "Foo bar\n   baz"', :action_view))
-  end
-  # Rails >= 3.2.3 adds a newline after opening textarea tags.
-  def self.rails_text_area_helpers_emit_a_newline?
-    major, minor, tiny = ActionPack::VERSION::MAJOR, ActionPack::VERSION::MINOR, ActionPack::VERSION::TINY
-    major == 4 || ((major == 3) && (minor >= 2) && (tiny >= 3))
-  end
-  def text_area_content_regex
-    @text_area_content_regex ||= if self.class.rails_text_area_helpers_emit_a_newline?
-      /<(textarea)[^>]*>\n(.*?)<\/\1>/im
-    else
-      /<(textarea)[^>]*>(.*?)<\/\1>/im
-    end
-  end
-  def test_text_area_tag
-    output = render('= text_area_tag "body", "Foo\nBar\n Baz\n   Boom"', :action_view)
-    match_data = output.match(text_area_content_regex)
-    assert_equal "Foo&#x000A;Bar&#x000A; Baz&#x000A;   Boom", match_data[2]
-  end
-  def test_text_area
-    output = render('= text_area :post, :body', :action_view)
-    match_data = output.match(text_area_content_regex)
-    assert_equal "Foo bar&#x000A;baz", match_data[2]
-  end
-  def test_partials_should_not_cause_textareas_to_be_indented
-    # non-indentation of textareas rendered inside partials
-    @base.instance_variable_set('@post', Post.new("Foo", nil, PostErrors.new))
-    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
-  if rails_text_area_helpers_emit_a_newline?
-    def test_textareas_should_prerve_leading_whitespace
-      # leading whitespace preservation
-      @base.instance_variable_set('@post', Post.new("    Foo", nil, PostErrors.new))
-      output = render(".foo\n  = text_area :post, :body", :action_view)
-      match_data = output.match(text_area_content_regex)
-      assert_equal '&#x0020;   Foo', match_data[2]
-    end
-    def test_textareas_should_prerve_leading_whitespace_in_partials
-      # leading whitespace in textareas rendered inside partials
-      @base.instance_variable_set('@post', Post.new("    Foo", nil, PostErrors.new))
-      output = render(".foo\n  .bar\n    = render '/text_area_helper'", :action_view)
-      match_data = output.match(text_area_content_regex)
-      assert_equal '&#x0020;   Foo', match_data[2]
-    end
-  end
-  def test_capture_haml
-    assert_equal(<<HTML, render(<<HAML))
-"<p>13</p>\\n"
-HTML
-- (foo = capture_haml(13) do |a|
-  %p= a
-- end)
-= foo.inspect
-HAML
-  end
-  def test_content_tag_block
-    assert_equal(<<HTML.strip, render(<<HAML, :action_view).strip)
-<div><p>bar</p>
-<strong>bar</strong>
-</div>
-HTML
-= content_tag :div do
-  %p bar
-  %strong bar
-HAML
-  end
-  def test_content_tag_error_wrapping
-    def @base.protect_against_forgery?; false; end
-    output = render(<<HAML, :action_view)
-= form_for @post, :as => :post, :html => {:class => nil, :id => nil}, :url => '' do |f|
-  = f.label 'error_field'
-HAML
-    fragment = Nokogiri::HTML.fragment(output)
-    refute_nil fragment.css('form div.field_with_errors label[for=post_error_field]').first
-  end
-  def test_form_tag_in_helper_with_string_block
-    def @base.protect_against_forgery?; false; end
-    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
-    assert_equal("<p id='some_id'></p>\n", render("- haml_tag 'p#some_id'"))
-  end
-  def test_haml_tag_name_attribute_with_colon_id
-    assert_equal("<p id='some:id'></p>\n", render("- haml_tag 'p#some:id'"))
-  end
-  def test_haml_tag_without_name_but_with_id
-    assert_equal("<div id='some_id'></div>\n", render("- haml_tag '#some_id'"))
-  end
-  def test_haml_tag_without_name_but_with_class
-    assert_equal("<div class='foo'></div>\n", render("- haml_tag '.foo'"))
-  end
-  def test_haml_tag_without_name_but_with_colon_class
-    assert_equal("<div class='foo:bar'></div>\n", render("- haml_tag '.foo:bar'"))
-  end
-  def test_haml_tag_name_with_id_and_class
-    assert_equal("<p class='foo' id='some_id'></p>\n", render("- haml_tag 'p#some_id.foo'"))
-  end
-  def test_haml_tag_name_with_class
-    assert_equal("<p class='foo'></p>\n", render("- haml_tag 'p.foo'"))
-  end
-  def test_haml_tag_name_with_class_and_id
-    assert_equal("<p class='foo' id='some_id'></p>\n", render("- haml_tag 'p.foo#some_id'"))
-  end
-  def test_haml_tag_name_with_id_and_multiple_classes
-    assert_equal("<p class='foo bar' id='some_id'></p>\n", render("- haml_tag 'p#some_id.foo.bar'"))
-  end
-  def test_haml_tag_name_with_multiple_classes_and_id
-    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_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
-    assert_equal("<p class='bar foo'></p>\n", render("- haml_tag 'p.foo', :class => 'bar'"))
-  end
-  def test_haml_tag_name_merges_id_and_attribute_id
-    assert_equal("<p id='foo_bar'></p>\n", render("- haml_tag 'p#foo', :id => 'bar'"))
-  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_with_class_array
-    assert_equal("<p class='a b'>foo</p>\n", render("- haml_tag :p, 'foo', :class => %w[a b]"))
-    assert_equal("<p class='a b c d'>foo</p>\n", render("- haml_tag 'p.c.d', 'foo', :class => %w[a b]"))
-  end
-  def test_haml_tag_with_id_array
-    assert_equal("<p id='a_b'>foo</p>\n", render("- haml_tag :p, 'foo', :id => %w[a b]"))
-    assert_equal("<p id='c_a_b'>foo</p>\n", render("- haml_tag 'p#c', 'foo', :id => %w[a b]"))
-  end
-  def test_haml_tag_with_data_hash
-    assert_equal("<p data-baz data-foo='bar'>foo</p>\n",
-      render("- haml_tag :p, 'foo', :data => {:foo => 'bar', :baz => true}"))
-  end
-  def test_haml_tag_non_autoclosed_tags_arent_closed
-    assert_equal("<p></p>\n", render("- haml_tag :p"))
-  end
-  def test_haml_tag_renders_text_on_a_single_line
-    assert_equal("<p>#{'a' * 100}</p>\n", render("- haml_tag :p, 'a' * 100"))
-  end
-  def test_haml_tag_raises_error_for_multiple_content
-    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_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_raises(Haml::Error) { render("= haml_tag :p") }
-  end
-  def test_haml_tag_with_multiline_string
-    assert_equal(<<HTML, render(<<HAML))
-<p>
-  foo
-  bar
-  baz
-</p>
-HTML
-- haml_tag :p, "foo\\nbar\\nbaz"
-HAML
-  end
-  def test_haml_concat_with_multiline_string
-    assert_equal(<<HTML, render(<<HAML))
-<p>
-  foo
-  bar
-  baz
-</p>
-HTML
-%p
-  - haml_concat "foo\\nbar\\nbaz"
-HAML
-  end
-  def test_haml_tag_with_ugly
-    assert_equal(<<HTML, render(<<HAML, :ugly => true))
-<p>
-<strong>Hi!</strong>
-</p>
-HTML
-- haml_tag :p do
-  - haml_tag :strong, "Hi!"
-HAML
-  end
-  def test_is_haml
-    assert(!ActionView::Base.new.is_haml?)
-    assert_equal("true\n", render("= is_haml?"))
-    assert_equal("true\n", render("= is_haml?", :action_view))
-    assert_equal("false", @base.render(:inline => '<%= is_haml? %>'))
-    assert_equal("false\n", render("= render :inline => '<%= is_haml? %>'", :action_view))
-  end
-  def test_page_class
-    controller = Struct.new(:controller_name, :action_name).new('troller', 'tion')
-    scope = Struct.new(:controller).new(controller)
-    result = render("%div{:class => page_class} MyDiv", :scope => scope)
-    expected = "<div class='troller tion'>MyDiv</div>\n"
-    assert_equal expected, result
-  end
-  def test_indented_capture
-    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
-      def trc(collection, &block)
-        collection.each do |record|
-          haml_concat capture_haml(record, &block)
-        end
-      end
-    end
-    assert_equal("1\n\n2\n\n3\n\n", render("- trc([1, 2, 3]) do |i|\n  = i.inspect"))
-  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
-    Haml::Helpers.module_eval do
-      def check_capture_returns_nil(&block)
-        contents = capture(&block)
-        contents << "ERROR" if contents
-      end
-    end
-    assert_equal("\n", render("= check_capture_returns_nil { 2 }", :action_view))
-  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"))
-  end
-  def test_find_and_preserve_with_block_and_tags
-    assert_equal("<pre>Foo\nBar</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>Foo&#x000A;Bar</pre>&#x000A;Foo&#x000A;Bar\n",
-                 render("= preserve do\n  %pre\n    Foo\n    Bar\n  Foo\n  Bar"))
-  end
-  def test_init_haml_helpers
-    context = Object.new
-    class << context
-      include Haml::Helpers
-    end
-    context.init_haml_helpers
-    result = context.capture_haml do
-      context.haml_tag :p, :attr => "val" do
-        context.haml_concat "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
-  def test_content_tag_nested
-    assert_equal "<span><div>something</div></span>", render("= nested_tag", :action_view).strip
-  end
-  def test_error_return
-    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.
-MESSAGE
-  end
-  def test_error_return_line
-    render("%p foo\n= haml_concat 'foo'\n%p bar")
-    assert false, "Expected Haml::Error"
-  rescue Haml::Error => e
-    assert_equal 2, e.backtrace[1].scan(/:(\d+)/).first.first.to_i
-  end
-  def test_error_return_line_in_helper
-    render("- something_that_uses_haml_concat")
-    assert false, "Expected Haml::Error"
-  rescue Haml::Error => e
-    assert_equal 15, e.backtrace[0].scan(/:(\d+)/).first.first.to_i
-  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
-  def test_capture_with_nuke_outer
-    assert_equal "<div></div>\n*<div>hi there!</div>\n", render(<<HAML)
-%div
-= precede("*") do
-  %div> hi there!
-HAML
-    assert_equal "<div></div>\n*<div>hi there!</div>\n", render(<<HAML)
-%div
-= precede("*") do
-  = "  "
-  %div> hi there!
-HAML
-  end
-  def test_html_escape
-    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"
-    assert_equal "&quot;&gt;&lt;&amp;\u00e9", Haml::Helpers.html_escape(string)
-    assert $stderr.string == "", "html_escape shouldn't generate warnings with UTF-8 strings: #{$stderr.string}"
-  ensure
-    $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
-  def test_escape_once_leaves_entity_references
-    assert_equal "&quot;&gt;&lt;&amp; &nbsp;", Haml::Helpers.escape_once('"><& &nbsp;')
-  end
-  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
-  end
-  def test_escape_once_encoding
-    old_stderr, $stderr = $stderr, StringIO.new
-    string = "\"><&\u00e9 &nbsp;"
-    assert_equal "&quot;&gt;&lt;&amp;\u00e9 &nbsp;", Haml::Helpers.escape_once(string)
-    assert $stderr.string == "", "html_escape shouldn't generate warnings with UTF-8 strings: #{$stderr.string}"
-  ensure
-    $stderr = old_stderr
-  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