haml 4.0.0 → 5.0.0

data/test/template_test.rb

@@ -2,48 +2,13 @@ require 'test_helper'
 require 'mocks/article'
 
 require 'action_pack/version'
+require 'template_test_helper'
 
-module Haml::Filters::Test
-  include Haml::Filters::Base
-
-  def render(text)
-    "TESTING HAHAHAHA!"
-  end
-end
-
-module Haml::Helpers
-  def test_partial(name, locals = {})
-    Haml::Engine.new(File.read(File.join(TemplateTest::TEMPLATE_PATH, "_#{name}.haml"))).render(self, locals)
-  end
-end
-
-class Egocentic
-  def method_missing(*args)
-    self
-  end
-end
-
-class DummyController
-  attr_accessor :logger
-  def initialize
-    @logger = Egocentic.new
-  end
-
-  def self.controller_path
-    ''
-  end
-
-  def controller_path
-    ''
-  end
-end
-
-class TemplateTest < MiniTest::Unit::TestCase
-  TEMPLATE_PATH = File.join(File.dirname(__FILE__), "templates")
+class TemplateTest < Haml::TestCase
   TEMPLATES = %w{          very_basic        standard    helpers
     whitespace_handling    original_engine   list        helpful
     silent_script          tag_parsing       just_stuff  partials
-    nuke_outer_whitespace  nuke_inner_whitespace
+    nuke_outer_whitespace  nuke_inner_whitespace         bemit
     render_layout partial_layout partial_layout_erb}
 
   def setup
@@ -56,10 +21,10 @@ class TemplateTest < MiniTest::Unit::TestCase
   def create_base
     vars = { 'article' => Article.new, 'foo' => 'value one' }
 
-    base = ActionView::Base.new(TEMPLATE_PATH, vars)
+    base = ActionView::Base.new(TemplateTestHelper::TEMPLATE_PATH, vars)
 
     # This is needed by RJS in (at least) Rails 3
-    base.instance_variable_set('@template', base)
+    base.instance_variable_set(:@template, base)
 
     # This is used by form_for.
     # It's usually provided by ActionController::Base.
@@ -83,12 +48,7 @@ class TemplateTest < MiniTest::Unit::TestCase
   def assert_renders_correctly(name, &render_method)
     old_options = Haml::Template.options.dup
     Haml::Template.options[:escape_html] = false
-    if ActionPack::VERSION::MAJOR < 2 ||
-        (ActionPack::VERSION::MAJOR == 2 && ActionPack::VERSION::MINOR < 2)
-      render_method ||= proc { |n| @base.render(n) }
-    else
-      render_method ||= proc { |n| @base.render(:file => n) }
-    end
+    render_method ||= proc { |n| @base.render(:file => n) }
 
     silence_warnings do
       load_result(name).split("\n").zip(render_method[name].split("\n")).each_with_index do |pair, line|
@@ -96,7 +56,7 @@ class TemplateTest < MiniTest::Unit::TestCase
         assert_equal(pair.first, pair.last, message)
       end
     end
-  rescue Haml::Util.av_template_class(:Error) => e
+  rescue ActionView::Template::Error => e
     if e.message =~ /Can't run [\w:]+ filter; required (one of|file) ((?:'\w+'(?: or )?)+)(, but none were found| not found)/
       puts "\nCouldn't require #{$2}; skipping a test."
     else
@@ -111,28 +71,51 @@ class TemplateTest < MiniTest::Unit::TestCase
   end
 
   TEMPLATES.each do |template|
-    define_method "test_template_should_render_correctly [template: #{template}] " do
+    define_method "test_template_should_render_correctly [template: #{template}]" do
       assert_renders_correctly template
     end
   end
 
+  def test_render_method_returning_null
+    @base.instance_eval do
+      def empty
+        nil
+      end
+      def render_something(&block)
+        capture(self, &block)
+      end
+    end
+
+    content_to_render = "%h1 This is part of the broken view.\n= render_something do |thing|\n  = thing.empty do\n    = 'test'"
+    result = render(content_to_render)
+    expected_result = "<h1>This is part of the broken view.</h1>\n"
+    assert_equal(expected_result, result)
+  end
+
+  def test_simple_rendering
+    content_to_render = "%p test\n= capture { 'foo' }"
+    result = render(content_to_render)
+    expected_result = "<p>test</p>\nfoo\n"
+    assert_equal(expected_result, result)
+  end
+
   def test_templates_should_render_correctly_with_render_proc
     assert_renders_correctly("standard") do |name|
-      engine = Haml::Engine.new(File.read(File.dirname(__FILE__) + "/templates/#{name}.haml"), :format => :xhtml)
+      engine = Haml::Engine.new(File.read(File.dirname(__FILE__) + "/templates/#{name}.haml"), format: :xhtml)
       engine.render_proc(@base).call
     end
   end
 
   def test_templates_should_render_correctly_with_def_method
     assert_renders_correctly("standard") do |name|
-      engine = Haml::Engine.new(File.read(File.dirname(__FILE__) + "/templates/#{name}.haml"), :format => :xhtml)
+      engine = Haml::Engine.new(File.read(File.dirname(__FILE__) + "/templates/#{name}.haml"), format: :xhtml)
       engine.def_method(@base, "render_standard")
       @base.render_standard
     end
   end
 
   def test_instance_variables_should_work_inside_templates
-    @base.instance_variable_set("@content_for_layout", 'something')
+    @base.instance_variable_set(:@content_for_layout, 'something')
     assert_equal("<p>something</p>", render("%p= @content_for_layout").chomp)
 
     @base.instance_eval("@author = 'Hampton Catlin'")
@@ -164,8 +147,8 @@ class TemplateTest < MiniTest::Unit::TestCase
     Haml::Template.options = old_options
   end
 
-  def test_with_output_buffer_with_ugly
-    assert_equal(<<HTML, render(<<HAML, :ugly => true))
+  def test_with_output_buffer
+    assert_equal(<<HTML, render(<<HAML))
 <p>
 foo
 baz
@@ -328,4 +311,12 @@ HTML
   Test
 HAML
   end
+
+  class ::TosUnsafeObject; def to_s; '<hr>'; end; end
+  class ::TosSafeObject; def to_s; '<hr>'.html_safe; end; end
+
+  def test_object_that_returns_safe_buffer
+    assert_equal("<hr>\n", render('= ::TosSafeObject.new', escape_html: true))
+    assert_equal("&lt;hr&gt;\n", render('= ::TosUnsafeObject.new', escape_html: true))
+  end
 end

data/test/template_test_helper.rb

@@ -0,0 +1,38 @@
+module TemplateTestHelper
+  TEMPLATE_PATH = File.join(__dir__, "templates")
+end
+
+module Haml::Filters::Test
+  include Haml::Filters::Base
+
+  def render(text)
+    "TESTING HAHAHAHA!"
+  end
+end
+
+module Haml::Helpers
+  def test_partial(name, locals = {})
+    Haml::Engine.new(File.read(File.join(TemplateTestHelper::TEMPLATE_PATH, "_#{name}.haml")), Haml::Template.options).render(self, locals)
+  end
+end
+
+class Egocentic
+  def method_missing(*args)
+    self
+  end
+end
+
+class DummyController
+  attr_accessor :logger
+  def initialize
+    @logger = Egocentic.new
+  end
+
+  def self.controller_path
+    ''
+  end
+
+  def controller_path
+    ''
+  end
+end

data/test/templates/_text_area_helper.html.haml

@@ -0,0 +1,4 @@
+- defined?(text_area_helper) and nil # silence a warning
+.foo
+  .bar
+    = text_area :post, :body

data/test/templates/bemit.haml

@@ -0,0 +1,3 @@
+.o-media@md.c-user.c-user--premium
+  %img.o-media__img@md.c-user__photo.c-avatar{src: '', alt: ''}
+  %p.o-media__body@md.c-user__bio ...

data/test/templates/just_stuff.haml

@@ -29,6 +29,7 @@
   \- character
   \%p foo
   \yee\ha
+  \   don't lstrip me
 / Short comment
 /
   This is a block comment

data/test/templates/partial_layout_erb.erb

@@ -1,4 +1,4 @@
 <h1>Partial layout used with for block:</h1>
 <%= render :layout => 'layout_for_partial' do -%>
-<p>Some content within a layout</p>
+Some content within a layout
 <% end %>

data/test/templates/standard_ugly.haml

@@ -0,0 +1 @@
+test/templates/standard.haml

data/test/templates/with_bom.haml

@@ -0,0 +1 @@
+BOMG

data/test/temple_line_counter_test.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+
+class TempleLineCounterTest < Haml::TestCase
+  TESTED_TEMPLES = [
+    [:multi,
+     [:code, "foo"],
+     [:static, "bar"],
+     [:dynamic, "baz"],
+    ],
+    [:multi,
+     [:code, "foo\nbar\nbaz"],
+     [:static, "foo\nbar\nbaz"],
+     [:dynamic, "foo\nbar\nbaz"],
+    ],
+    [:case,
+     ["'a\nb', false", [:static, "hello\n"]],
+     [:else, [:code, "raise 'error\n'"]],
+    ],
+    [:escape, true, [:dynamic, "foo\nbar"]],
+    [:escape, :once, [:dynamic, "foo\nbar"]],
+    [:escape, false, [:dynamic, "foo\nbar"]],
+    [:escape, true, [:static, "foo\nbar"]],
+    [:escape, :once, [:static, "foo\nbar"]],
+    [:escape, false, [:dynamic, "foo\nbar"]],
+  ]
+
+  def test_count_lines
+    TESTED_TEMPLES.each do |temple|
+      code = Haml::TempleEngine.chain.inject(temple) do |exp, (symbol, filter)|
+        case symbol
+        when :Parser, :Compiler
+          exp
+        else
+          filter.call(Haml::TempleEngine).call(exp)
+        end
+      end
+      assert_equal code.count("\n"), Haml::TempleLineCounter.count_lines(temple)
+    end
+  end
+end

data/test/test_helper.rb

@@ -1,19 +1,32 @@
+begin
+  if ENV['TRAVIS'] && RUBY_VERSION == '2.1.2' && !defined?(Rubinius)
+    require 'coveralls'
+    Coveralls.wear!
+  end
+rescue LoadError
+  # ignore error for other test Gemfiles
+end
+
 if ENV["COVERAGE"]
   require "simplecov"
   SimpleCov.start
 end
 
-require 'rubygems'
-gem "minitest"
 require 'bundler/setup'
 require 'minitest/autorun'
 require 'action_pack'
 require 'action_controller'
 require 'action_view'
+require 'action_view/base'
 require 'nokogiri'
-
 require 'rails'
+
+if defined?(I18n.enforce_available_locales)
+  I18n.enforce_available_locales = true
+end
+
 class TestApp < Rails::Application
+  config.eager_load = false
   config.root = ""
 end
 Rails.application = TestApp
@@ -27,17 +40,23 @@ $VERBOSE = true
 require 'haml'
 require 'haml/template'
 
-Haml::Template.options[:ugly]   = false
+TestApp.initialize!
+
 Haml::Template.options[:format] = :xhtml
 
+BASE_TEST_CLASS = if defined?(Minitest::Test)
+                    Minitest::Test
+                  else
+                    MiniTest::Unit::TestCase
+                  end
+
 module Declarative
   def test(name, &block)
-    define_method("test #{name}", &block)
+    define_method("test_ #{name}", &block)
   end
 end
 
-class MiniTest::Unit::TestCase
-
+class Haml::TestCase < BASE_TEST_CLASS
   extend Declarative
 
   def render(text, options = {}, base = nil, &block)
@@ -65,10 +84,6 @@ class MiniTest::Unit::TestCase
     Haml::Util.silence_warnings(&block)
   end
 
-  def rails_form_opener
-    '<div style="margin:0;padding:0;display:inline"><input name="utf8" type="hidden" value="&#x2713;" /></div>'
-  end
-
   def assert_raises_message(klass, message)
     yield
   rescue Exception => e
@@ -81,5 +96,4 @@ class MiniTest::Unit::TestCase
   def self.error(*args)
     Haml::Error.message(*args)
   end
-
 end

data/test/util_test.rb

@@ -1,21 +1,8 @@
 require 'test_helper'
 
-class UtilTest < MiniTest::Unit::TestCase
+class UtilTest < Haml::TestCase
   include Haml::Util
 
-  def test_powerset
-    return unless Set[Set[]] == Set[Set[]] # There's a bug in Ruby 1.8.6 that breaks nested set equality
-    assert_equal([[].to_set].to_set,
-      powerset([]))
-    assert_equal([[].to_set, [1].to_set].to_set,
-      powerset([1]))
-    assert_equal([[].to_set, [1].to_set, [2].to_set, [1, 2].to_set].to_set,
-      powerset([1, 2]))
-    assert_equal([[].to_set, [1].to_set, [2].to_set, [3].to_set,
-        [1, 2].to_set, [2, 3].to_set, [1, 3].to_set, [1, 2, 3].to_set].to_set,
-      powerset([1, 2, 3]))
-  end
-
   def test_silence_warnings
     old_stderr, $stderr = $stderr, StringIO.new
     warn "Out"
@@ -26,38 +13,10 @@ class UtilTest < MiniTest::Unit::TestCase
     $stderr = old_stderr
   end
 
-  def test_caller_info
-    assert_equal(["/tmp/foo.rb", 12, "fizzle"], caller_info("/tmp/foo.rb:12: in `fizzle'"))
-    assert_equal(["/tmp/foo.rb", 12, nil], caller_info("/tmp/foo.rb:12"))
-    assert_equal(["(haml)", 12, "blah"], caller_info("(haml):12: in `blah'"))
-    assert_equal(["", 12, "boop"], caller_info(":12: in `boop'"))
-    assert_equal(["/tmp/foo.rb", -12, "fizzle"], caller_info("/tmp/foo.rb:-12: in `fizzle'"))
-    assert_equal(["/tmp/foo.rb", 12, "fizzle"], caller_info("/tmp/foo.rb:12: in `fizzle {}'"))
-  end
-
-  def test_def_static_method
-    klass = Class.new
-    def_static_method(klass, :static_method, [:arg1, :arg2],
-      :sarg1, :sarg2, <<RUBY)
-      s = "Always " + arg1
-      s << " <% if sarg1 %>and<% else %>but never<% end %> " << arg2
-
-      <% if sarg2 %>
-        s << "."
-      <% end %>
-RUBY
-    c = klass.new
-    assert_equal("Always brush your teeth and comb your hair.",
-      c.send(static_method_name(:static_method, true, true),
-        "brush your teeth", "comb your hair"))
-    assert_equal("Always brush your teeth and comb your hair",
-      c.send(static_method_name(:static_method, true, false),
-        "brush your teeth", "comb your hair"))
-    assert_equal("Always brush your teeth but never play with fire.",
-      c.send(static_method_name(:static_method, false, true),
-        "brush your teeth", "play with fire"))
-    assert_equal("Always brush your teeth but never play with fire",
-      c.send(static_method_name(:static_method, false, false),
-        "brush your teeth", "play with fire"))
+  def test_check_encoding_does_not_destoy_the_given_string
+    string_with_bom = File.read(File.dirname(__FILE__) + '/templates/with_bom.haml', :encoding => Encoding::UTF_8)
+    original = string_with_bom.dup
+    check_encoding(string_with_bom)
+    assert_equal(original, string_with_bom)
   end
 end