gem.gems.haml-3.1.1.test.haml.helper_test.rb Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of stapler-jruby Show documentation

JRuby binding for Stapler

There is a newer version: 1.263

#!/usr/bin/env ruby
require File.dirname(__FILE__) + '/../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
end

class HelperTest < Test::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

    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 = {})
    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
Bar", Haml::Helpers.flatten("Foo\nBar"))

    assert_equal("Hello
World!
YOU ARE FLAT?
OMGZ!",
      Haml::Helpers.flatten("Hello\nWorld!\nYOU ARE \rFLAT?\n\rOMGZ!"))
  end

  def test_list_of_should_render_correctly
    assert_equal("1
\n2\n", render("= list_of([1, 2]) do |i|\n  = i"))
    assert_equal("[1]\n", render("= list_of([[1]]) do |i|\n  = i.inspect"))
    assert_equal("\n  Fee
\n  A word!
\n
\n\n  Fi
\n  A word!
\n
\n\n  Fo
\n  A word!
\n
\n\n  Fum
\n  A word!
\n\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") =~ /#/)
    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("          tabbed\n", render("- buffer.tabulation=5\n%p tabbed"))
  end

  def test_with_tabs
    assert_equal(< "<%= 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
    assert_equal(<#{rails_form_opener}
  bar
  baz

HTML
#{rails_block_helper_char} form_tag 'foo' do
  %p bar
  %strong baz
HAML
  end

  def test_text_area
    assert_equal(%(Foo
Bar
 Baz
   Boom\n),
                 render('= text_area_tag "body", "Foo\nBar\n Baz\n   Boom"', :action_view))

    assert_equal(%(Foo bar
baz\n),
                 render('= text_area :post, :body', :action_view))    

    assert_equal(%(Foo bar
   baz\n),
                 render('= content_tag "pre", "Foo bar\n   baz"', :action_view))    
  end
  
  def test_capture_haml
    assert_equal(<13\\n"
HTML
- (foo = capture_haml(13) do |a|
  %p= a
- end; nil)
= foo.dump
HAML
  end

  def test_content_tag_block
    assert_equal(<bar
bar


HTML
#{rails_block_helper_char} content_tag :div do
  %p bar
  %strong bar
HAML
  end

  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(<#{rails_form_opener}
  Error field

HTML
#{rails_block_helper_char} form_for #{form_for_calling_convention('post')}, :url => '' do |f|
  = f.label 'error_field'
HAML
  end

  def test_form_tag_in_helper_with_string_block
    def @base.protect_against_forgery?; false; end
    assert_equal(<#{rails_form_opener}bar
HTML
#{rails_block_helper_char} wacky_form
HAML
  end

  def test_haml_tag_name_attribute_with_id
    assert_equal("\n", render("- haml_tag 'p#some_id'"))
  end

  def test_haml_tag_name_attribute_with_colon_id
    assert_equal("\n", render("- haml_tag 'p#some:id'"))
  end

  def test_haml_tag_without_name_but_with_id
    assert_equal("\n", render("- haml_tag '#some_id'"))
  end

  def test_haml_tag_without_name_but_with_class
    assert_equal("\n", render("- haml_tag '.foo'"))
  end

  def test_haml_tag_without_name_but_with_colon_class
    assert_equal("\n", render("- haml_tag '.foo:bar'"))
  end

  def test_haml_tag_name_with_id_and_class
    assert_equal("\n", render("- haml_tag 'p#some_id.foo'"))
  end

  def test_haml_tag_name_with_class
    assert_equal("\n", render("- haml_tag 'p.foo'"))
  end

  def test_haml_tag_name_with_class_and_id
    assert_equal("\n", render("- haml_tag 'p.foo#some_id'"))
  end

  def test_haml_tag_name_with_id_and_multiple_classes
    assert_equal("\n", render("- haml_tag 'p#some_id.foo.bar'"))
  end

  def test_haml_tag_name_with_multiple_classes_and_id
    assert_equal("\n", render("- haml_tag 'p.foo.bar#some_id'"))
  end

  def test_haml_tag_name_and_attribute_classes_merging
    assert_equal("\n", render("- haml_tag 'p#some_id.foo', :class => 'bar'"))
  end

  def test_haml_tag_name_and_attribute_classes_merging
    assert_equal("\n", render("- haml_tag 'p.foo', :class => 'bar'"))
  end

  def test_haml_tag_name_merges_id_and_attribute_id
    assert_equal("\n", render("- haml_tag 'p#foo', :id => 'bar'"))
  end

  def test_haml_tag_attribute_html_escaping
    assert_equal("baz\n", render("%p{:id => 'foo&bar'} baz", :escape_html => true))
  end

  def test_haml_tag_autoclosed_tags_are_closed
    assert_equal("
\n", render("- haml_tag :br, :class => 'foo'"))
  end

  def test_haml_tag_with_class_array
    assert_equal("foo\n", render("- haml_tag :p, 'foo', :class => %w[a b]"))
    assert_equal("foo\n", render("- haml_tag 'p.c.d', 'foo', :class => %w[a b]"))
  end

  def test_haml_tag_with_id_array
    assert_equal("foo\n", render("- haml_tag :p, 'foo', :id => %w[a b]"))
    assert_equal("foo\n", render("- haml_tag 'p#c', 'foo', :id => %w[a b]"))
  end

  def test_haml_tag_with_data_hash
    assert_equal("foo\n",
      render("- haml_tag :p, 'foo', :data => {:foo => 'bar', :baz => true}"))
  end

  def test_haml_tag_non_autoclosed_tags_arent_closed
    assert_equal("\n", render("- haml_tag :p"))
  end

  def test_haml_tag_renders_text_on_a_single_line
    assert_equal("#{'a' * 100}\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("\n", render("- haml_tag :p, :/"))
    assert_equal("
kumquat\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_haml_tag_with_multiline_string
    assert_equal(<
  foo
  bar
  baz

HTML
- haml_tag :p, "foo\\nbar\\nbaz"
HAML
  end

  def test_haml_concat_with_multiline_string
    assert_equal(<
  foo
  bar
  baz

HTML
%p
  - haml_concat "foo\\nbar\\nbaz"
HAML
  end

  def test_haml_tag_with_ugly
    assert_equal(< true))

Hi!

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_object => scope)
    expected = "MyDiv\n"
    assert_equal expected, result
  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 %>"))
  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("Foo
Bar\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("Foo\nBar\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("Foo
Bar
Foo
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("\n  Blah\n\n", result)
  end

  def test_non_haml
    assert_equal("false\n", render("= non_haml { is_haml? }"))
  end

  def test_content_tag_nested
    assert_equal "something", render("= nested_tag", :action_view).strip
  end

  def test_error_return
    assert_raise(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 16, 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 "some tag content", ActsLikeTag.new.to_s
  end

  def test_capture_with_nuke_outer
    assert_equal "
\n*hi there!
\n", render(< hi there!
HAML

    assert_equal "
\n*hi there!
\n", render(< hi there!
HAML
  end
end