drnic-haml 2.3.0

data/test/haml/helper_test.rb

@@ -0,0 +1,282 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../test_helper'
+require 'haml/template'
+
+class ActionView::Base
+  def nested_tag
+    content_tag(:span) {content_tag(:div) {"something"}}
+  end
+end
+
+module Haml::Helpers
+  def something_that_uses_haml_concat
+    haml_concat('foo').to_s
+  end
+end
+
+class HelperTest < Test::Unit::TestCase
+  Post = Struct.new('Post', :body)
+  
+  def setup
+    @base = ActionView::Base.new
+    @base.controller = ActionController::Base.new
+
+    if defined?(ActionController::Response)
+      # This is needed for >=3.0.0
+      @base.controller.response = ActionController::Response.new
+    end
+
+    @base.instance_variable_set('@post', Post.new("Foo bar\nbaz"))
+  end
+
+  def render(text, options = {})
+    if options == :action_view
+      @base.render :inline => text, :type => :haml
+    else
+      scope = options.delete :scope_object
+      Haml::Engine.new(text, options).to_html(scope ? scope : Object.new)
+    end
+  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!"))
+  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_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, ActionView::TemplateError
+      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
+    result = render("- form_tag 'foo' do\n  %p bar\n  %strong baz", :action_view)
+    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_content_tag_block
+    assert_equal(<<HTML.strip, render(<<HAML, :action_view))
+<div><p>bar</p>
+<strong>bar</strong>
+</div>
+HTML
+- content_tag :div do
+  %p bar
+  %strong bar
+HAML
+  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></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_raise(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") }
+  end
+
+  def test_haml_tag_error_return
+    assert_raise(Haml::Error) { render("= haml_tag :p") }
+  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_object => scope)
+    expected = "<div class='troller tion'>MyDiv</div>\n"
+    assert_equal expected, result
+  end
+
+  def test_indented_capture
+    assert_equal("  \n  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_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_raise(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[0].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 13, 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
+end
+

data/test/haml/html2haml_test.rb

@@ -0,0 +1,258 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../test_helper'
+require 'haml/html'
+
+class Html2HamlTest < Test::Unit::TestCase
+
+  def test_empty_render_should_remain_empty
+    assert_equal '', render('')
+  end
+
+  def test_id_and_class_should_be_removed_from_hash
+    assert_equal '%span#foo.bar', render('<span id="foo" class="bar"> </span>')
+  end
+
+  def test_no_tag_name_for_div_if_class_or_id_is_present
+    assert_equal '#foo', render('<div id="foo"> </div>')
+    assert_equal '.foo', render('<div class="foo"> </div>')
+  end
+
+  def test_multiple_class_names
+    assert_equal '.foo.bar.baz', render('<div class=" foo  bar  baz "> </div>')
+  end
+
+  def test_should_have_pretty_attributes
+    assert_equal_attributes('%input{ :type => "text", :name => "login" }',
+      render('<input type="text" name="login" />'))
+    assert_equal_attributes('%meta{ "http-equiv" => "Content-Type", :content => "text/html" }',
+      render('<meta http-equiv="Content-Type" content="text/html" />'))
+  end
+
+  def test_sqml_comment
+    assert_equal "/\n  IE sucks", render('<!-- IE sucks -->')
+  end
+
+  def test_rhtml
+    assert_equal '- foo = bar', render_rhtml('<% foo = bar %>')
+    assert_equal '- foo = bar', render_rhtml('<% foo = bar -%>')
+    assert_equal '= h @item.title', render_rhtml('<%=h @item.title %>')
+    assert_equal '= h @item.title', render_rhtml('<%=h @item.title -%>')
+  end
+  
+  def test_rhtml_with_html_special_chars
+    assert_equal '= 3 < 5 ? "OK" : "Your computer is b0rken"',
+      render_rhtml(%Q{<%= 3 < 5 ? "OK" : "Your computer is b0rken" %>})
+  end
+  
+  def test_rhtml_in_class_attribute
+    assert_equal "%div{ :class => dyna_class }\n  I have a dynamic attribute",
+      render_rhtml(%Q{<div class="<%= dyna_class %>">I have a dynamic attribute</div>})
+  end
+  
+  def test_rhtml_in_id_attribute
+    assert_equal "%div{ :id => dyna_id }\n  I have a dynamic attribute",
+      render_rhtml(%Q{<div id="<%= dyna_id %>">I have a dynamic attribute</div>})
+  end
+  
+  def test_rhtml_in_attribute_results_in_string_interpolation
+    assert_equal %(%div{ :id => "item_\#{i}" }\n  Ruby string interpolation FTW),
+      render_rhtml(%Q{<div id="item_<%= i %>">Ruby string interpolation FTW</div>})
+  end
+  
+  def test_rhtml_in_attribute_with_trailing_content
+    assert_equal %(%div{ :class => "\#{12}!" }\n  Bang!),
+      render_rhtml(%Q{<div class="<%= 12 %>!">Bang!</div>})
+  end
+  
+  def test_rhtml_in_attribute_to_multiple_interpolations
+    assert_equal %(%div{ :class => "\#{12} + \#{13}" }\n  Math is super),
+      render_rhtml(%Q{<div class="<%= 12 %> + <%= 13 %>">Math is super</div>})
+  end
+  
+  def test_whitespace_eating_erb_tags
+    assert_equal %(- form_for),
+      render_rhtml(%Q{<%- form_for -%>})
+  end
+
+  def test_blocks_and_consuming_end_tags
+    html = <<-HTML.gsub(/^    /, '')
+    <% if @post %>
+      <% @post.comments.each do |comment| -%>
+        <p><%= comment.name %></p>
+      <% end -%>
+    <% end %>
+    HTML
+    expected = <<-EOS.gsub(/^    /, '').strip
+    - if @post
+      - @post.comments.each do |comment|
+        %p
+          = comment.name
+    EOS
+    assert_equal expected, render_rhtml(html)
+  end
+
+  def test_advanced_template
+    html = <<-HTML.gsub(/^    /, '')
+    <%
+      date = Date.today
+      date = date.to_s
+    %>
+    <% if @post %>
+      <p><%= "only do for each comment" %></p>
+      <p>- Don't chomp minus -</p>
+      <p class="class_name" id="foo" other_attribute="value">
+        This
+        is
+        multiline
+        HTML text
+      </p>
+      <%= @post.comments.map do |comment|
+        comment.name
+      end.join("\\n") %>
+      <% @post.comments.each do |comment| -%>
+        <p><%= "for inside each comment do something" %></p>
+      <% end -%>
+    <% end %>
+    HTML
+    
+    # The 'extra' space on the 'end.join("\\n")' is meant to
+    # be there since the escape makes it one character less
+    expected = <<-EOS.gsub(/^    /, '').strip
+    - date = Date.today
+    - date = date.to_s
+    - if @post
+      %p
+        = "only do for each comment"
+      %p
+        \\- Don't chomp minus -
+      %p#foo.class_name{ :other_attribute => "value" }
+        This
+        is
+        multiline
+        HTML text
+      = @post.comments.map do |comment| |
+        comment.name                    |
+        end.join("\\n")                  |
+      - @post.comments.each do |comment|
+        %p
+          = "for inside each comment do something"
+    EOS
+    assert_equal expected, render_rhtml(html)
+  end  
+  
+  def test_content_for_block
+    html = <<-HTML.gsub(/^    /, '')
+    <% content_for :header do %>
+      My Header
+    <% end %>
+    <% content_for :account do -%>
+      Logged as <a href="#" title="Admin">Admin</a> (<a href="#" title="Logout">logout</a>)
+    <% end -%>
+    <% content_for :footer do %>
+      My Footer
+    <% end %>
+    HTML
+    expected = <<-RUBY.gsub(/^    /, '').strip
+    - content_for :header do
+      My Header
+    - content_for :account do
+      Logged as
+      %a{ :href => "#", :title => "Admin" }
+        Admin
+      (
+      %a{ :href => "#", :title => "Logout" }
+        logout
+      )
+    - content_for :footer do
+      My Footer
+    RUBY
+    assert_equal expected, render_rhtml(html)
+  end
+  
+  def test_intermediate_format_with_loud_and_silent_tags
+    html = <<-HTML.gsub(/^    /, '')
+    <p>Hi there</p>
+    <haml:silent>
+      if @post
+      <haml:block>
+        <haml:loud>@post.title</haml:loud>
+      </haml:block>
+      else
+      <haml:block>
+        <haml:loud>"Unknown"</haml:loud>
+      </haml:block>
+    </haml:silent>
+    <haml:silent> content_for :header do 
+      <haml:block>My Header</haml:block>
+    </haml:silent>
+    <p>Goodbye</p>
+    HTML
+    expected = <<-HAML.gsub(/^    /, '').strip
+    %p
+      Hi there
+    - if @post
+      = @post.title
+    - else
+      = "Unknown"
+    - content_for :header do
+      My Header
+    %p
+      Goodbye
+    HAML
+    assert_equal expected, render_rhtml(html)
+  end
+
+  def test_cdata
+    assert_equal(<<HAML.strip, render(<<HTML))
+%p
+  :cdata
+    <a foo="bar" baz="bang">
+    <div id="foo">flop</div>
+    </a>
+HAML
+<p><![CDATA[
+  <a foo="bar" baz="bang">
+    <div id="foo">flop</div>
+  </a>
+]]></p>
+HTML
+  end
+
+  # Encodings
+
+  unless Haml::Util.ruby1_8?
+    def test_encoding_error
+      render("foo\nbar\nb\xFEaz".force_encoding("utf-8"))
+      assert(false, "Expected exception")
+    rescue Haml::Error => e
+      assert_equal(3, e.line)
+      assert_equal('Invalid UTF-8 character "\xFE"', e.message)
+    end
+
+    def test_ascii_incompatible_encoding_error
+      template = "foo\nbar\nb_z".encode("utf-16le")
+      template[9] = "\xFE".force_encoding("utf-16le")
+      render(template)
+      assert(false, "Expected exception")
+    rescue Haml::Error => e
+      assert_equal(3, e.line)
+      assert_equal('Invalid UTF-16LE character "\xFE"', e.message)
+    end
+  end
+
+  protected
+
+  def render(text, options = {})
+    Haml::HTML.new(text, options).render.rstrip
+  end
+
+  def render_rhtml(text)
+    render(text, :rhtml => true)
+  end
+
+  def assert_equal_attributes(expected, result)
+    expected_attr, result_attr = [expected, result].map { |s| s.gsub!(/\{ (.+) \}/, ''); $1.split(', ').sort }
+    assert_equal expected_attr, result_attr
+    assert_equal expected, result
+  end
+end