tilt 1.4.1 → 2.0.0.beta1

data/test/tilt_lesstemplate_test.rb

@@ -1,11 +1,11 @@
-require 'contest'
+require 'test_helper'
 require 'tilt'
 
 begin
   require 'pathname'
-  require 'less'
+  require 'tilt/less'
 
-  class LessTemplateTest < Test::Unit::TestCase
+  class LessTemplateTest < Minitest::Test
     def assert_similar(a, b)
       assert_equal a.gsub(/\s+/m, ' '), b.gsub(/\s+/m, ' ')
     end

data/test/tilt_liquidtemplate_test.rb

@@ -1,10 +1,10 @@
-require 'contest'
+require 'test_helper'
 require 'tilt'
 
 begin
-  require 'liquid'
+  require 'tilt/liquid'
 
-  class LiquidTemplateTest < Test::Unit::TestCase
+  class LiquidTemplateTest < Minitest::Test
     test "registered for '.liquid' files" do
       assert_equal Tilt::LiquidTemplate, Tilt['test.liquid']
     end

data/test/tilt_mapping.rb

@@ -0,0 +1,215 @@
+require 'test_helper'
+require 'tilt'
+require 'tilt/mapping'
+
+module Tilt
+
+  class MappingTest < Minitest::Test
+    class Stub
+    end
+
+    class Stub2
+    end
+
+    setup do
+      @mapping = Mapping.new
+    end
+
+    test "registered?" do
+      @mapping.register(Stub, 'foo', 'bar')
+      assert @mapping.registered?('foo')
+      assert @mapping.registered?('bar')
+      refute @mapping.registered?('baz')
+    end
+
+    test "lookups on registered" do
+      @mapping.register(Stub, 'foo', 'bar')
+      assert_equal Stub, @mapping['foo']
+      assert_equal Stub, @mapping['bar']
+      assert_equal Stub, @mapping['hello.foo']
+      assert_nil @mapping['foo.baz']
+    end
+
+    test "can be dup'd" do
+      @mapping.register(Stub, 'foo')
+      other = @mapping.dup
+      assert other.registered?('foo')
+
+      # @mapping doesn't leak to other
+      @mapping.register(Stub, 'bar')
+      refute other.registered?('bar')
+
+      # other doesn't leak to @mapping
+      other.register(Stub, 'baz')
+      refute @mapping.registered?('baz')
+    end
+
+    context "lazy with one template class" do
+      setup do
+        @mapping.register_lazy('MyTemplate', 'my_template', 'mt')
+      end
+
+      teardown do
+        Object.send :remove_const, :MyTemplate if defined? ::MyTemplate
+      end
+
+      test "registered?" do
+        assert @mapping.registered?('mt')
+      end
+
+      test "basic lookup" do
+        req = proc do |file|
+          assert_equal 'my_template', file
+          class ::MyTemplate; end
+          true
+        end
+
+        @mapping.stub :require, req do
+          klass = @mapping['hello.mt']
+          assert_equal ::MyTemplate, klass
+        end
+      end
+
+      test "doesn't require when template class is present" do
+        class ::MyTemplate; end
+
+        req = proc do |file|
+          flunk "#require shouldn't be called"
+        end
+
+        @mapping.stub :require, req do
+          klass = @mapping['hello.mt']
+          assert_equal ::MyTemplate, klass
+        end
+      end
+
+      test "raises NameError when the class name is defined" do
+        req = proc do |file|
+          # do nothing
+        end
+
+        @mapping.stub :require, req do
+          assert_raises(NameError) do
+            @mapping['hello.mt']
+          end
+        end
+      end
+
+      test "warns when there's multiple threads" do
+        Thread.new do
+          req = proc do |file|
+            class ::MyTemplate; end
+          end
+
+          @mapping.stub :require, req do
+            assert_output '', /autoloading 'my_template'/ do
+              @mapping['hello.mt']
+            end
+          end
+        end.join
+      end
+    end
+
+    context "lazy with two template classes" do
+      setup do
+        @mapping.register_lazy('MyTemplate1', 'my_template1', 'mt')
+        @mapping.register_lazy('MyTemplate2', 'my_template2', 'mt')
+      end
+
+      teardown do
+        Object.send :remove_const, :MyTemplate1 if defined? ::MyTemplate1
+        Object.send :remove_const, :MyTemplate2 if defined? ::MyTemplate2
+      end
+
+      test "registered?" do
+        assert @mapping.registered?('mt')
+      end
+
+      test "only attempt to load the last template" do
+        req = proc do |file|
+          assert_equal 'my_template2', file
+          class ::MyTemplate2; end
+          true
+        end
+
+        @mapping.stub :require, req do
+          klass = @mapping['hello.mt']
+          assert_equal ::MyTemplate2, klass
+        end
+      end
+
+      test "uses the first template if it's present" do
+        class ::MyTemplate1; end
+
+        req = proc do |file|
+          flunk
+        end
+
+        @mapping.stub :require, req do
+          klass = @mapping['hello.mt']
+          assert_equal ::MyTemplate1, klass
+        end
+      end
+
+      test "falls back when LoadError is thrown" do
+        req = proc do |file|
+          raise LoadError unless file == 'my_template1'
+          class ::MyTemplate1; end
+          true
+        end
+
+        @mapping.stub :require, req do
+          klass = @mapping['hello.mt']
+          assert_equal ::MyTemplate1, klass
+        end
+      end
+
+      test "raises the first LoadError when everything fails" do
+        req = proc do |file|
+          raise LoadError, file
+        end
+
+        @mapping.stub :require, req do
+          err = assert_raises(LoadError) do
+            klass = @mapping['hello.mt']
+          end
+
+          assert_equal 'my_template2', err.message
+        end
+      end
+
+      test "handles autoloaded constants" do
+        Object.autoload :MyTemplate2, 'my_template2'
+        class ::MyTemplate1; end
+
+        assert_equal MyTemplate1, @mapping['hello.mt']
+      end
+    end
+
+    test "raises NameError on invalid class name" do
+      @mapping.register_lazy '#foo', 'my_template', 'mt'
+
+      req = proc do |file|
+        # do nothing
+      end
+
+      @mapping.stub :require, req do
+        assert_raises(NameError) do
+          @mapping['hello.mt']
+        end
+      end
+    end
+
+    context "#templates_for" do
+      setup do
+        @mapping.register Stub, 'a'
+        @mapping.register Stub2, 'b'
+      end
+
+      test "handles multiple engines" do
+        assert_equal [Stub2, Stub], @mapping.templates_for('hello/world.a.b')
+      end
+    end
+  end
+end
+

data/test/tilt_markaby_test.rb

@@ -1,10 +1,10 @@
-require 'contest'
+require 'test_helper'
 require 'tilt'
 
 begin
-  require 'markaby'
+  require 'tilt/markaby'
 
-  class MarkabyTiltTest <  Test::Unit::TestCase
+  class MarkabyTiltTest <  Minitest::Test
     def setup
       @block = lambda do |t|
         File.read(File.dirname(__FILE__) + "/#{t.file}")
@@ -85,4 +85,4 @@ begin
 
 rescue LoadError => boom
   warn "Tilt::MarkabyTemplate (disabled)"
-end
+end

data/test/tilt_markdown_test.rb

@@ -1,5 +1,6 @@
 # coding: UTF-8
 require 'tilt'
+require 'test_helper'
 
 begin
 require 'nokogiri'
@@ -38,9 +39,6 @@ module MarkdownTests
   end
 
   def test_escape_html_true
-    if self.class.template == Tilt::RedcarpetTemplate
-      flunk "redcarpet doesn't support :escape_html yet"
-    end
     html = nrender "Hello <b>World</b>", :escape_html => true
     assert_equal "<p>Hello &lt;b&gt;World&lt;/b&gt;</p>", html
   end
@@ -77,9 +75,9 @@ module MarkdownTests
 end
 
 begin
-  require 'rdiscount'
+  require 'tilt/rdiscount'
 
-  class MarkdownRDiscountTest < Test::Unit::TestCase
+  class MarkdownRDiscountTest < Minitest::Test
     include MarkdownTests
     template Tilt::RDiscountTemplate
   end
@@ -88,17 +86,18 @@ rescue LoadError => boom
 end
 
 begin
-  require 'redcarpet'
+  require 'tilt/redcarpet'
 
-  class MarkdownRedcarpetTest < Test::Unit::TestCase
+  class MarkdownRedcarpetTest < Minitest::Test
     include MarkdownTests
     template Tilt::RedcarpetTemplate
     # Doesn't support escaping
     undef test_escape_html_true
 
     def test_smarty_pants_true
+      # Various versions of Redcarpet support various versions of Smart pants.
       html = nrender "Hello ``World'' -- This is --- a test ...", :smartypants => true
-      assert_equal "<p>Hello “World'' – This is — a test …</p>", html
+      assert_match /<p>Hello “World(''|”) – This is — a test …<\/p>/, html
     end
 
     def test_fenced_code_blocks_with_lang
@@ -117,9 +116,9 @@ rescue LoadError => boom
 end
 
 begin
-  require 'bluecloth'
+  require 'tilt/bluecloth'
 
-  class MarkdownBlueClothTest < Test::Unit::TestCase
+  class MarkdownBlueClothTest < Minitest::Test
     include MarkdownTests
     template Tilt::BlueClothTemplate
   end
@@ -128,9 +127,9 @@ rescue LoadError => boom
 end
 
 begin
-  require 'kramdown'
+  require 'tilt/kramdown'
 
-  class MarkdownKramdownTest < Test::Unit::TestCase
+  class MarkdownKramdownTest < Minitest::Test
     include MarkdownTests
     template Tilt::KramdownTemplate
     # Doesn't support escaping
@@ -146,9 +145,9 @@ end
 
 
 begin
-  require 'maruku'
+  require 'tilt/maruku'
 
-  class MarkdownMarukuTest < Test::Unit::TestCase
+  class MarkdownMarukuTest < Minitest::Test
     include MarkdownTests
     template Tilt::MarukuTemplate
     # Doesn't support escaping

data/test/tilt_marukutemplate_test.rb

@@ -1,27 +1,15 @@
-require 'contest'
+require 'test_helper'
 require 'tilt'
 
 begin
-  require 'maruku'
-
-  class MarukuTemplateTest < Test::Unit::TestCase
-    test "registered for '.md' files" do
-      assert Tilt.mappings['md'].include?(Tilt::MarukuTemplate)
-    end
-
-    test "registered for '.mkd' files" do
-      assert Tilt.mappings['mkd'].include?(Tilt::MarukuTemplate)
-    end
-
-    test "registered for '.markdown' files" do
-      assert Tilt.mappings['markdown'].include?(Tilt::MarukuTemplate)
-    end
+  require 'tilt/maruku'
 
+  class MarukuTemplateTest < Minitest::Test
     test "registered below Kramdown" do
       %w[md mkd markdown].each do |ext|
-        mappings = Tilt.mappings[ext]
-        kram_idx = mappings.index(Tilt::KramdownTemplate)
-        maru_idx = mappings.index(Tilt::MarukuTemplate)
+        lazy = Tilt.lazy_map[ext]
+        kram_idx = lazy.index { |klass, file| klass == 'Tilt::KramdownTemplate' }
+        maru_idx = lazy.index { |klass, file| klass == 'Tilt::MarukuTemplate' }
         assert maru_idx > kram_idx,
           "#{maru_idx} should be higher than #{kram_idx}"
       end

data/test/tilt_metadata_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+require 'tilt/template'
+
+module Tilt
+  class TemplateMetadataTest < Minitest::Test
+    class MyTemplate < Template
+      metadata[:global] = 1
+      self.default_mime_type = 'text/html'
+
+      def prepare
+      end
+
+      def allows_script?
+        true
+      end
+    end
+
+    test "global metadata" do
+      assert MyTemplate.metadata
+      assert_equal 1, MyTemplate.metadata[:global]
+    end
+
+    test "instance metadata" do
+      tmpl = MyTemplate.new { '' }
+      assert_equal 1, tmpl.metadata[:global]
+    end
+
+    test "gracefully handles default_mime_type" do
+      assert_equal 'text/html', MyTemplate.metadata[:mime_type]
+    end
+
+    test "still allows .default_mime_type" do
+      assert_equal 'text/html', MyTemplate.default_mime_type
+    end
+
+    test "gracefully handles allows_script?" do
+      tmpl = MyTemplate.new { '' }
+      assert_equal true, tmpl.metadata[:allows_script]
+    end
+  end
+end
+

data/test/tilt_nokogiritemplate_test.rb

@@ -1,9 +1,9 @@
-require 'contest'
+require 'test_helper'
 require 'tilt'
 
 begin
-  require 'nokogiri'
-  class NokogiriTemplateTest < Test::Unit::TestCase
+  require 'tilt/nokogiri'
+  class NokogiriTemplateTest < Minitest::Test
     test "registered for '.nokogiri' files" do
       assert_equal Tilt::NokogiriTemplate, Tilt['test.nokogiri']
       assert_equal Tilt::NokogiriTemplate, Tilt['test.xml.nokogiri']

data/test/tilt_radiustemplate_test.rb

@@ -1,14 +1,14 @@
-require 'contest'
+require 'test_helper'
 require 'tilt'
 
 begin
-  require 'radius'
+  require 'tilt/radius'
 
   # Disable radius tests under Ruby versions >= 1.9.1 since it's still buggy.
   # Remove when fixed upstream.
   raise LoadError if RUBY_VERSION >= "1.9.1" and Radius.version < "0.7"
 
-  class RadiusTemplateTest < Test::Unit::TestCase
+  class RadiusTemplateTest < Minitest::Test
     test "registered for '.radius' files" do
       assert_equal Tilt::RadiusTemplate, Tilt['test.radius']
     end