tilt 1.4.1 → 2.0.0

data/test/tilt_asciidoctor_test.rb

@@ -1,10 +1,10 @@
-require 'contest'
+require 'test_helper'
 require 'tilt'
 
 begin
-  require 'asciidoctor'
+  require 'tilt/asciidoc'
 
-  class AsciidoctorTemplateTest < Test::Unit::TestCase
+  class AsciidoctorTemplateTest < Minitest::Test
     HTML5_OUTPUT = "<div class=\"sect1\"><h2 id=\"_hello_world\">Hello World!</h2><div class=\"sectionbody\"></div></div>"
     DOCBOOK_OUTPUT = "<section id=\"_hello_world\"><title>Hello World!</title></section>"
 
@@ -13,15 +13,15 @@ begin
     end
 
     test "registered for '.ad' files" do
-      assert Tilt.mappings['ad'].include?(Tilt::AsciidoctorTemplate)
+      assert_equal Tilt::AsciidoctorTemplate, Tilt['ad']
     end
 
     test "registered for '.adoc' files" do
-      assert Tilt.mappings['adoc'].include?(Tilt::AsciidoctorTemplate)
+      assert_equal Tilt::AsciidoctorTemplate, Tilt['adoc']
     end
 
     test "registered for '.asciidoc' files" do
-      assert Tilt.mappings['asciidoc'].include?(Tilt::AsciidoctorTemplate)
+      assert_equal Tilt::AsciidoctorTemplate, Tilt['asciidoc']
     end
 
     test "preparing and evaluating html5 templates on #render" do

data/test/tilt_blueclothtemplate_test.rb

@@ -1,22 +1,10 @@
-require 'contest'
+require 'test_helper'
 require 'tilt'
 
 begin
-  require 'bluecloth'
-
-  class BlueClothTemplateTest < Test::Unit::TestCase
-    test "registered for '.md' files" do
-      assert Tilt.mappings['md'].include?(Tilt::BlueClothTemplate)
-    end
-
-    test "registered for '.mkd' files" do
-      assert Tilt.mappings['mkd'].include?(Tilt::BlueClothTemplate)
-    end
-
-    test "registered for '.markdown' files" do
-      assert Tilt.mappings['markdown'].include?(Tilt::BlueClothTemplate)
-    end
+  require 'tilt/bluecloth'
 
+  class BlueClothTemplateTest < Minitest::Test
     test "preparing and evaluating templates on #render" do
       template = Tilt::BlueClothTemplate.new { |t| "# Hello World!" }
       assert_equal "<h1>Hello World!</h1>", template.render

data/test/tilt_buildertemplate_test.rb

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

data/test/tilt_cache_test.rb

@@ -1,7 +1,7 @@
-require 'contest'
+require 'test_helper'
 require 'tilt'
 
-class TiltCacheTest < Test::Unit::TestCase
+class TiltCacheTest < Minitest::Test
   setup { @cache = Tilt::Cache.new }
 
   test "caching with single simple argument to #fetch" do

data/test/tilt_coffeescripttemplate_test.rb

@@ -1,20 +1,10 @@
-require 'contest'
+require 'test_helper'
 require 'tilt'
 
 begin
-  require 'coffee_script'
+  require 'tilt/coffee'
 
-  class CoffeeScriptTemplateTest < Test::Unit::TestCase
-
-    unless method_defined?(:assert_not_match)
-      # assert_not_match is missing on 1.8.7, which uses assert_no_match
-      def assert_not_match(a, b)
-        unless a.kind_of?(Regexp)
-          a = Regexp.new(Regexp.escape(a))
-        end
-        assert_no_match(a,b)
-      end
-    end
+  class CoffeeScriptTemplateTest < Minitest::Test
 
     test "is registered for '.coffee' files" do
       assert_equal Tilt::CoffeeScriptTemplate, Tilt['test.coffee']
@@ -42,11 +32,11 @@ begin
       assert_match "puts(\"Hello \" + name);\n", template.render
 
       template = Tilt::CoffeeScriptTemplate.new(:bare => true) { str }
-      assert_not_match "(function() {", template.render
+      refute_match "(function() {", template.render
       assert_equal "var name;\n\nname = \"Josh\";\n\nputs(\"Hello \" + name);\n", template.render
 
       template2 = Tilt::CoffeeScriptTemplate.new(:no_wrap => true) { str}
-      assert_not_match "(function() {", template.render
+      refute_match "(function() {", template.render
       assert_equal "var name;\n\nname = \"Josh\";\n\nputs(\"Hello \" + name);\n", template.render
     end
 
@@ -69,13 +59,13 @@ begin
       test "overridden by :bare" do
         template = Tilt::CoffeeScriptTemplate.new(:bare => true) { |t| 'name = "Josh"; puts "Hello, #{name}"' }
         assert_match "puts(\"Hello, \" + name);", template.render
-        assert_not_match "(function() {", template.render
+        refute_match "(function() {", template.render
       end
 
       test "overridden by :no_wrap" do
         template = Tilt::CoffeeScriptTemplate.new(:no_wrap => true) { |t| 'name = "Josh"; puts "Hello, #{name}"' }
         assert_match "puts(\"Hello, \" + name);", template.render
-        assert_not_match "(function() {", template.render
+        refute_match "(function() {", template.render
       end
     end
 
@@ -92,7 +82,7 @@ begin
       test "no options" do
         template = Tilt::CoffeeScriptTemplate.new { |t| 'name = "Josh"; puts "Hello, #{name}"' }
         assert_match "puts(\"Hello, \" + name);", template.render
-        assert_not_match "(function() {", template.render
+        refute_match "(function() {", template.render
       end
 
       test "overridden by :bare" do

data/test/tilt_compilesite_test.rb

@@ -1,8 +1,8 @@
-require 'contest'
+require 'test_helper'
 require 'tilt'
 require 'thread'
 
-class CompileSiteTest < Test::Unit::TestCase
+class CompileSiteTest < Minitest::Test
   def setup
     GC.start
   end

data/test/tilt_creoletemplate_test.rb

@@ -1,18 +1,14 @@
-require 'contest'
+require 'test_helper'
 require 'tilt'
 
 begin
-  require 'creole'
+  require 'tilt/creole'
 
-  class CreoleTemplateTest < Test::Unit::TestCase
+  class CreoleTemplateTest < Minitest::Test
     test "is registered for '.creole' files" do
       assert_equal Tilt::CreoleTemplate, Tilt['test.creole']
     end
 
-    test "registered for '.wiki' files" do
-      assert Tilt.mappings['wiki'].include?(Tilt::CreoleTemplate)
-    end
-
     test "compiles and evaluates the template on #render" do
       template = Tilt::CreoleTemplate.new { |t| "= Hello World!" }
       assert_equal "<h1>Hello World!</h1>", template.render

data/test/tilt_csv_test.rb

@@ -1,17 +1,13 @@
-require 'contest'
+require 'test_helper'
 require 'tilt'
 
 begin
-  if RUBY_VERSION >= '1.9.0'
-    require 'csv'
-  else
-    require 'fastercsv'
-  end
+  require 'tilt/csv'
 
-  class CSVTemplateTest < Test::Unit::TestCase
+  class CSVTemplateTest < Minitest::Test
 
     test "registered for '.rcsv' files" do
-      assert Tilt.mappings['rcsv'].include?(Tilt::CSVTemplate)
+      assert_equal Tilt::CSVTemplate, Tilt['rcsv']
     end
 
     test "compiles and evaluates the template on #render" do
@@ -66,4 +62,4 @@ raise NameError
 
 # rows
 csv << ['Frog', 2]
-csv << ['Cat', 5]
+csv << ['Cat', 5]

data/test/tilt_erbtemplate_test.rb

@@ -1,16 +1,16 @@
 # coding: utf-8
-require 'contest'
+require 'test_helper'
 require 'tilt'
-require 'erb'
+require 'tilt/erb'
 require 'tempfile'
 
-class ERBTemplateTest < Test::Unit::TestCase
+class ERBTemplateTest < Minitest::Test
   test "registered for '.erb' files" do
-    assert Tilt.mappings['erb'].include?(Tilt::ERBTemplate)
+    assert_includes Tilt.lazy_map['erb'], ['Tilt::ERBTemplate', 'tilt/erb']
   end
 
   test "registered for '.rhtml' files" do
-    assert Tilt.mappings['rhtml'].include?(Tilt::ERBTemplate)
+    assert_includes Tilt.lazy_map['rhtml'], ['Tilt::ERBTemplate', 'tilt/erb']
   end
 
   test "loading and evaluating templates on #render" do
@@ -45,7 +45,7 @@ class ERBTemplateTest < Test::Unit::TestCase
       template = Tilt::ERBTemplate.new { '<% self.exposed_buffer = @_out_buf %>hey' }
       scope = MockOutputVariableScope.new
       template.render(scope)
-      assert_not_nil scope.exposed_buffer
+      refute_nil scope.exposed_buffer
       assert_equal scope.exposed_buffer, 'hey'
     ensure
       Tilt::ERBTemplate.default_output_variable = '_erbout'
@@ -118,7 +118,7 @@ class ERBTemplateTest < Test::Unit::TestCase
   end
 end
 
-class CompiledERBTemplateTest < Test::Unit::TestCase
+class CompiledERBTemplateTest < Minitest::Test
   def teardown
     GC.start
   end

data/test/tilt_erubistemplate_test.rb

@@ -1,9 +1,9 @@
-require 'contest'
+require 'test_helper'
 require 'tilt'
 
 begin
-  require 'erubis'
-  class ErubisTemplateTest < Test::Unit::TestCase
+  require 'tilt/erubis'
+  class ErubisTemplateTest < Minitest::Test
     test "registered for '.erubis' files" do
       assert_equal Tilt::ErubisTemplate, Tilt['test.erubis']
       assert_equal Tilt::ErubisTemplate, Tilt['test.html.erubis']
@@ -11,9 +11,9 @@ begin
 
     test "registered above ERB" do
       %w[erb rhtml].each do |ext|
-        mappings = Tilt.mappings[ext]
-        erubis_idx = mappings.index(Tilt::ErubisTemplate)
-        erb_idx = mappings.index(Tilt::ERBTemplate)
+        lazy = Tilt.lazy_map[ext]
+        erubis_idx = lazy.index { |klass, file| klass == 'Tilt::ErubisTemplate' }
+        erb_idx = lazy.index { |klass, file| klass == 'Tilt::ERBTemplate' }
         assert erubis_idx < erb_idx,
           "#{erubis_idx} should be lower than #{erb_idx}"
       end
@@ -51,7 +51,7 @@ begin
         template = Tilt::ErubisTemplate.new { '<% self.exposed_buffer = @_out_buf %>hey' }
         scope = MockOutputVariableScope.new
         template.render(scope)
-        assert_not_nil scope.exposed_buffer
+        refute_nil scope.exposed_buffer
         assert_equal scope.exposed_buffer, 'hey'
       ensure
         Tilt::ErubisTemplate.default_output_variable = '_erbout'

data/test/tilt_etannitemplate_test.rb

@@ -1,7 +1,8 @@
-require 'contest'
+require 'test_helper'
 require 'tilt'
+require 'tilt/etanni'
 
-class EtanniTemplateTest < Test::Unit::TestCase
+class EtanniTemplateTest < Minitest::Test
   test "registered for '.etn' files" do
     assert_equal Tilt::EtanniTemplate, Tilt['test.etn']
   end
@@ -77,7 +78,7 @@ class EtanniTemplateTest < Test::Unit::TestCase
 end
 
 
-class CompiledEtanniTemplateTest < Test::Unit::TestCase
+class CompiledEtanniTemplateTest < Minitest::Test
   def teardown
     GC.start
   end

data/test/tilt_hamltemplate_test.rb

@@ -1,13 +1,13 @@
-require 'contest'
+require 'test_helper'
 require 'tilt'
 
 begin
   class ::MockError < NameError
   end
 
-  require 'haml'
+  require 'tilt/haml'
 
-  class HamlTemplateTest < Test::Unit::TestCase
+  class HamlTemplateTest < Minitest::Test
     test "registered for '.haml' files" do
       assert_equal Tilt::HamlTemplate, Tilt['test.haml']
     end
@@ -71,7 +71,7 @@ begin
     end
   end
 
-  class CompiledHamlTemplateTest < Test::Unit::TestCase
+  class CompiledHamlTemplateTest < Minitest::Test
     class Scope
     end
 

data/test/tilt_kramdown_test.rb

@@ -1,40 +1,18 @@
-require 'contest'
+require 'test_helper'
 require 'tilt'
 
 begin
-  require 'kramdown'
-
-  class MarukuTemplateTest < Test::Unit::TestCase
-    test "registered for '.md' files" do
-      assert Tilt.mappings['md'].include?(Tilt::KramdownTemplate)
-    end
-
-    test "registered for '.mkd' files" do
-      assert Tilt.mappings['mkd'].include?(Tilt::KramdownTemplate)
-    end
-
-    test "registered for '.markdown' files" do
-      assert Tilt.mappings['markdown'].include?(Tilt::KramdownTemplate)
-    end
-
-    test "registered above MarukuTemplate" do
-      %w[md mkd markdown].each do |ext|
-        mappings = Tilt.mappings[ext]
-        kram_idx = mappings.index(Tilt::KramdownTemplate)
-        maru_idx = mappings.index(Tilt::MarukuTemplate)
-        assert kram_idx < maru_idx,
-          "#{kram_idx} should be lower than #{maru_idx}"
-      end
-    end
+  require 'tilt/kramdown'
 
+  class KramdownTemplateTest < Minitest::Test
     test "preparing and evaluating templates on #render" do
       template = Tilt::KramdownTemplate.new { |t| "# Hello World!" }
-      assert_equal "<h1 id='hello_world'>Hello World!</h1>", template.render
+      assert_equal '<h1 id="hello-world">Hello World!</h1>', template.render.strip
     end
 
     test "can be rendered more than once" do
       template = Tilt::KramdownTemplate.new { |t| "# Hello World!" }
-      3.times { assert_equal "<h1 id='hello_world'>Hello World!</h1>", template.render }
+      3.times { assert_equal '<h1 id="hello-world">Hello World!</h1>', template.render.strip }
     end
   end
 rescue LoadError => boom

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_test.rb

@@ -0,0 +1,229 @@
+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
+
+    test "#extensions_for" do
+      @mapping.register(Stub, 'foo', 'bar')
+      assert_equal ['foo', 'bar'].sort, @mapping.extensions_for(Stub).sort
+    end
+
+    test "supports old-style #register" do
+      @mapping.register('foo', Stub)
+      assert_equal Stub, @mapping['foo']
+    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 "#extensions_for" do
+        assert_equal ['mt'], @mapping.extensions_for('MyTemplate')
+      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