tilt 0.3 → 0.4

data/test/tilt_buildertemplate_test.rb

@@ -0,0 +1,44 @@
+require 'contest'
+require 'tilt'
+
+begin
+  require 'builder'
+  class BuilderTemplateTest < Test::Unit::TestCase
+    test "registered for '.builder' files" do
+      assert_equal Tilt::BuilderTemplate, Tilt['test.builder']
+      assert_equal Tilt::BuilderTemplate, Tilt['test.xml.builder']
+    end
+
+    test "compiling and evaluating the template on #render" do
+      template = Tilt::BuilderTemplate.new { |t| "xml.em 'Hello World!'" }
+      assert_equal "<em>Hello World!</em>\n", template.render
+    end
+
+    test "passing locals" do
+      template = Tilt::BuilderTemplate.new { "xml.em('Hey ' + name + '!')" }
+      assert_equal "<em>Hey Joe!</em>\n", template.render(Object.new, :name => 'Joe')
+    end
+
+    test "evaluating in an object scope" do
+      template = Tilt::BuilderTemplate.new { "xml.em('Hey ' + @name + '!')" }
+      scope = Object.new
+      scope.instance_variable_set :@name, 'Joe'
+      assert_equal "<em>Hey Joe!</em>\n", template.render(scope)
+    end
+
+    test "passing a block for yield" do
+      template = Tilt::BuilderTemplate.new { "xml.em('Hey ' + yield + '!')" }
+      assert_equal "<em>Hey Joe!</em>\n", template.render { 'Joe' }
+    end
+
+    test "block style templates" do
+      template =
+        Tilt::BuilderTemplate.new do |t|
+          lambda { |xml| xml.em('Hey Joe!') }
+        end
+      assert_equal "<em>Hey Joe!</em>\n", template.render
+    end
+  end
+rescue LoadError
+  warn "Tilt::BuilderTemplate (disabled)"
+end

data/test/tilt_cache_test.rb

@@ -0,0 +1,33 @@
+require 'contest'
+require 'tilt'
+
+class TiltCacheTest < Test::Unit::TestCase
+  setup { @cache = Tilt::Cache.new }
+
+  test "caching with single simple argument to #fetch" do
+    template = nil
+    result = @cache.fetch('hello') { template = Tilt::StringTemplate.new {''} }
+    assert_same template, result
+    result = @cache.fetch('hello') { fail 'should be cached' }
+    assert_same template, result
+  end
+
+  test "caching with multiple complex arguments to #fetch" do
+    template = nil
+    args = ['hello', {:foo => 'bar', :baz => 'bizzle'}]
+    result = @cache.fetch(*args) { template = Tilt::StringTemplate.new {''} }
+    assert_same template, result
+    result = @cache.fetch(*args) { fail 'should be cached' }
+    assert_same template, result
+  end
+
+  test "clearing the cache with #clear" do
+    template, other = nil
+    result = @cache.fetch('hello') { template = Tilt::StringTemplate.new {''} }
+    assert_same template, result
+
+    @cache.clear
+    result = @cache.fetch('hello') { other = Tilt::StringTemplate.new {''} }
+    assert_same other, result
+  end
+end

data/test/tilt_erbtemplate_test.rb

@@ -0,0 +1,93 @@
+require 'contest'
+require 'tilt'
+require 'erb'
+
+class ERBTemplateTest < Test::Unit::TestCase
+  test "registered for '.erb' files" do
+    assert_equal Tilt::ERBTemplate, Tilt['test.erb']
+    assert_equal Tilt::ERBTemplate, Tilt['test.html.erb']
+  end
+
+  test "registered for '.rhtml' files" do
+    assert_equal Tilt::ERBTemplate, Tilt['test.rhtml']
+  end
+
+  test "compiling and evaluating templates on #render" do
+    template = Tilt::ERBTemplate.new { |t| "Hello World!" }
+    assert_equal "Hello World!", template.render
+  end
+
+  test "passing locals" do
+    template = Tilt::ERBTemplate.new { 'Hey <%= name %>!' }
+    assert_equal "Hey Joe!", template.render(Object.new, :name => 'Joe')
+  end
+
+  test "evaluating in an object scope" do
+    template = Tilt::ERBTemplate.new { 'Hey <%= @name %>!' }
+    scope = Object.new
+    scope.instance_variable_set :@name, 'Joe'
+    assert_equal "Hey Joe!", template.render(scope)
+  end
+
+  test "passing a block for yield" do
+    template = Tilt::ERBTemplate.new { 'Hey <%= yield %>!' }
+    assert_equal "Hey Joe!", template.render { 'Joe' }
+  end
+
+  test "backtrace file and line reporting without locals" do
+    data = File.read(__FILE__).split("\n__END__\n").last
+    fail unless data[0] == ?<
+    template = Tilt::ERBTemplate.new('test.erb', 11) { data }
+    begin
+      template.render
+      fail 'should have raised an exception'
+    rescue => boom
+      assert_kind_of NameError, boom
+      line = boom.backtrace.first
+      file, line, meth = line.split(":")
+      assert_equal 'test.erb', file
+      assert_equal '13', line
+    end
+  end
+
+  test "backtrace file and line reporting with locals" do
+    data = File.read(__FILE__).split("\n__END__\n").last
+    fail unless data[0] == ?<
+    template = Tilt::ERBTemplate.new('test.erb', 1) { data }
+    begin
+      template.render(nil, :name => 'Joe', :foo => 'bar')
+      fail 'should have raised an exception'
+    rescue => boom
+      assert_kind_of RuntimeError, boom
+      line = boom.backtrace.first
+      file, line, meth = line.split(":")
+      assert_equal 'test.erb', file
+      assert_equal '6', line
+    end
+  end
+
+  test "default non-stripping trim mode" do
+    template = Tilt.new('test.erb', 1) { "\n<%= 1 + 1 %>\n" }
+    assert_equal "\n2\n", template.render
+  end
+
+  test "stripping trim mode" do
+    template = Tilt.new('test.erb', 1, :trim => '-') { "\n<%= 1 + 1 -%>\n" }
+    assert_equal "\n2", template.render
+  end
+
+  test "shorthand whole line syntax trim mode" do
+    template = Tilt.new('test.erb', 1, :trim => '%') { "\n% if true\nhello\n%end\n" }
+    assert_equal "\nhello\n", template.render
+  end
+end
+
+__END__
+<html>
+<body>
+  <h1>Hey <%= name %>!</h1>
+
+
+  <p><% fail %></p>
+</body>
+</html>

data/test/tilt_erubistemplate_test.rb

@@ -0,0 +1,85 @@
+require 'contest'
+require 'tilt'
+
+begin
+  require 'erubis'
+  class ErubisTemplateTest < Test::Unit::TestCase
+    test "registered for '.erubis' files" do
+      assert_equal Tilt::ErubisTemplate, Tilt['test.erubis']
+      assert_equal Tilt::ErubisTemplate, Tilt['test.html.erubis']
+    end
+
+    test "compiling and evaluating templates on #render" do
+      template = Tilt::ErubisTemplate.new { |t| "Hello World!" }
+      assert_equal "Hello World!", template.render
+    end
+
+    test "passing locals" do
+      template = Tilt::ErubisTemplate.new { 'Hey <%= name %>!' }
+      assert_equal "Hey Joe!", template.render(Object.new, :name => 'Joe')
+    end
+
+    test "evaluating in an object scope" do
+      template = Tilt::ErubisTemplate.new { 'Hey <%= @name %>!' }
+      scope = Object.new
+      scope.instance_variable_set :@name, 'Joe'
+      assert_equal "Hey Joe!", template.render(scope)
+    end
+
+    test "passing a block for yield" do
+      template = Tilt::ErubisTemplate.new { 'Hey <%= yield %>!' }
+      assert_equal "Hey Joe!", template.render { 'Joe' }
+    end
+
+    test "backtrace file and line reporting without locals" do
+      data = File.read(__FILE__).split("\n__END__\n").last
+      fail unless data[0] == ?<
+      template = Tilt::ErubisTemplate.new('test.erubis', 11) { data }
+      begin
+        template.render
+        fail 'should have raised an exception'
+      rescue => boom
+        assert_kind_of NameError, boom
+        line = boom.backtrace.first
+        file, line, meth = line.split(":")
+        assert_equal 'test.erubis', file
+        assert_equal '13', line
+      end
+    end
+
+    test "backtrace file and line reporting with locals" do
+      data = File.read(__FILE__).split("\n__END__\n").last
+      fail unless data[0] == ?<
+      template = Tilt::ErubisTemplate.new('test.erubis', 1) { data }
+      begin
+        template.render(nil, :name => 'Joe', :foo => 'bar')
+        fail 'should have raised an exception'
+      rescue => boom
+        assert_kind_of RuntimeError, boom
+        line = boom.backtrace.first
+        file, line, meth = line.split(":")
+        assert_equal 'test.erubis', file
+        assert_equal '6', line
+      end
+    end
+
+    test "erubis template options" do
+      template = Tilt::ErubisTemplate.new(nil, :pattern => '\{% %\}') { 'Hey {%= @name %}!' }
+      scope = Object.new
+      scope.instance_variable_set :@name, 'Joe'
+      assert_equal "Hey Joe!", template.render(scope)
+    end
+  end
+rescue LoadError => boom
+  warn "Tilt::ErubisTemplate (disabled)\n"
+end
+
+__END__
+<html>
+<body>
+  <h1>Hey <%= name %>!</h1>
+
+
+  <p><% fail %></p>
+</body>
+</html>

data/test/{spec_tilt_hamltemplate.rb → tilt_hamltemplate_test.rb}

@@ -1,4 +1,4 @@
-require 'bacon'
+require 'contest'
 require 'tilt'
 
 begin
@@ -7,34 +7,34 @@ begin
 
   require 'haml'
 
-  describe Tilt::HamlTemplate do
-    it "is registered for '.haml' files" do
-      Tilt['test.haml'].should.equal Tilt::HamlTemplate
+  class HamlTemplateTest < Test::Unit::TestCase
+    test "registered for '.haml' files" do
+      assert_equal Tilt::HamlTemplate, Tilt['test.haml']
     end
 
-    it "compiles and evaluates the template on #render" do
+    test "compiling and evaluating templates on #render" do
       template = Tilt::HamlTemplate.new { |t| "%p Hello World!" }
-      template.render.should.equal "<p>Hello World!</p>\n"
+      assert_equal "<p>Hello World!</p>\n", template.render
     end
 
-    it "supports locals" do
+    test "passing locals" do
       template = Tilt::HamlTemplate.new { "%p= 'Hey ' + name + '!'" }
-      template.render(Object.new, :name => 'Joe').should.equal "<p>Hey Joe!</p>\n"
+      assert_equal "<p>Hey Joe!</p>\n", template.render(Object.new, :name => 'Joe')
     end
 
-    it "is evaluated in the object scope provided" do
+    test "evaluating in an object scope" do
       template = Tilt::HamlTemplate.new { "%p= 'Hey ' + @name + '!'" }
       scope = Object.new
       scope.instance_variable_set :@name, 'Joe'
-      template.render(scope).should.equal "<p>Hey Joe!</p>\n"
+      assert_equal "<p>Hey Joe!</p>\n", template.render(scope)
     end
 
-    it "evaluates template_source with yield support" do
+    test "passing a block for yield" do
       template = Tilt::HamlTemplate.new { "%p= 'Hey ' + yield + '!'" }
-      template.render { 'Joe' }.should.equal "<p>Hey Joe!</p>\n"
+      assert_equal "<p>Hey Joe!</p>\n", template.render { 'Joe' }
     end
 
-    it "reports the file and line properly in backtraces without locals" do
+    test "backtrace file and line reporting without locals" do
       data = File.read(__FILE__).split("\n__END__\n").last
       fail unless data[0] == ?%
       template = Tilt::HamlTemplate.new('test.haml', 10) { data }
@@ -42,26 +42,26 @@ begin
         template.render
         fail 'should have raised an exception'
       rescue => boom
-        boom.should.be.kind_of NameError
+        assert_kind_of NameError, boom
         line = boom.backtrace.first
         file, line, meth = line.split(":")
-        file.should.equal 'test.haml'
-        line.should.equal '12'
+        assert_equal 'test.haml', file
+        assert_equal '12', line
       end
     end
 
-    it "reports the file and line properly in backtraces with locals" do
+    test "backtrace file and line reporting with locals" do
       data = File.read(__FILE__).split("\n__END__\n").last
       fail unless data[0] == ?%
       template = Tilt::HamlTemplate.new('test.haml') { data }
       begin
         res = template.render(Object.new, :name => 'Joe', :foo => 'bar')
       rescue => boom
-        boom.should.be.kind_of ::MockError
+        assert_kind_of MockError, boom
         line = boom.backtrace.first
         file, line, meth = line.split(":")
-        file.should.equal 'test.haml'
-        line.should.equal '5'
+        assert_equal 'test.haml', file
+        assert_equal '5', line
       end
     end
   end

data/test/tilt_liquidtemplate_test.rb

@@ -0,0 +1,73 @@
+require 'contest'
+require 'tilt'
+
+begin
+  require 'liquid'
+
+  class LiquidTemplateTest < Test::Unit::TestCase
+    test "registered for '.liquid' files" do
+      assert_equal Tilt::LiquidTemplate, Tilt['test.liquid']
+    end
+
+    test "compiling and evaluating templates on #render" do
+      template = Tilt::LiquidTemplate.new { |t| "Hello World!" }
+      assert_equal "Hello World!", template.render
+    end
+
+    test "passing locals" do
+      template = Tilt::LiquidTemplate.new { "Hey {{ name }}!" }
+      assert_equal "Hey Joe!", template.render(nil, :name => 'Joe')
+    end
+
+    # Object's passed as "scope" to LiquidTemplate may respond to
+    # #to_h with a Hash. The Hash's contents are merged underneath
+    # Tilt locals.
+    class ExampleLiquidScope
+      def to_h
+        { :beer => 'wet', :whisky => 'wetter' }
+      end
+    end
+
+    test "combining scope and locals when scope responds to #to_h" do
+      template =
+        Tilt::LiquidTemplate.new {
+          'Beer is {{ beer }} but Whisky is {{ whisky }}.'
+        }
+      scope = ExampleLiquidScope.new
+      assert_equal "Beer is wet but Whisky is wetter.", template.render(scope)
+    end
+
+    test "precedence when locals and scope define same variables" do
+      template =
+        Tilt::LiquidTemplate.new {
+          'Beer is {{ beer }} but Whisky is {{ whisky }}.'
+        }
+      scope = ExampleLiquidScope.new
+      assert_equal "Beer is great but Whisky is greater.",
+        template.render(scope, :beer => 'great', :whisky => 'greater')
+    end
+
+    # Object's passed as "scope" to LiquidTemplate that do not
+    # respond to #to_h are silently ignored.
+    class ExampleIgnoredLiquidScope
+    end
+
+    test "handling scopes that do not respond to #to_h" do
+      template = Tilt::LiquidTemplate.new { 'Whisky' }
+      scope = ExampleIgnoredLiquidScope.new
+      assert_equal "Whisky", template.render(scope)
+    end
+
+    test "passing a block for yield" do
+      template =
+        Tilt::LiquidTemplate.new {
+          'Beer is {{ yield }} but Whisky is {{ content }}ter.'
+        }
+      assert_equal "Beer is wet but Whisky is wetter.",
+        template.render({}) { 'wet' }
+    end
+  end
+
+rescue LoadError => boom
+  warn "Tilt::LiquidTemplate (disabled)\n"
+end

data/test/{spec_tilt_mustachetemplate.rb → tilt_mustachetemplate_test.rb}

@@ -1,40 +1,40 @@
-require 'bacon'
+require 'contest'
 require 'tilt'
 
 begin
   require 'mustache'
   raise LoadError, "mustache version must be > 0.2.2" if !Mustache.respond_to?(:compiled?)
 
-  describe Tilt::MustacheTemplate do
-    it "is registered for '.mustache' files" do
-      Tilt['test.mustache'].should.equal Tilt::MustacheTemplate
+  module Views
+    class Foo < Mustache
+      attr_reader :foo
+    end
+  end
+
+  class MustacheTemplateTest < Test::Unit::TestCase
+    test "registered for '.mustache' files" do
+      assert_equal Tilt::MustacheTemplate, Tilt['test.mustache']
     end
 
-    it "compiles and evaluates the template on #render" do
+    test "compiling and evaluating templates on #render" do
       template = Tilt::MustacheTemplate.new { |t| "Hello World!" }
-      template.render.should.equal "Hello World!"
+      assert_equal "Hello World!", template.render
     end
 
-    it "supports locals" do
+    test "passing locals" do
       template = Tilt::MustacheTemplate.new { "<p>Hey {{name}}!</p>" }
-      template.render(nil, :name => 'Joe').should.equal "<p>Hey Joe!</p>"
+      assert_equal "<p>Hey Joe!</p>", template.render(nil, :name => 'Joe')
     end
 
-    it "evaluates template_source with yield support" do
+    test "passing a block for yield" do
       template = Tilt::MustacheTemplate.new { "<p>Hey {{yield}}!</p>" }
-      template.render { 'Joe' }.should.equal "<p>Hey Joe!</p>"
-    end
-
-    module Views
-      class Foo < Mustache
-        attr_reader :foo
-      end
+      assert_equal "<p>Hey Joe!</p>", template.render { 'Joe' }
     end
 
-    it "locates views defined at the top-level by default" do
+    test "locating views defined at the top-level" do
       template = Tilt::MustacheTemplate.new('foo.mustache') { "<p>Hey {{foo}}!</p>" }
       template.compile
-      template.engine.should.equal Views::Foo
+      assert_equal Views::Foo, template.engine
     end
 
     module Bar
@@ -44,18 +44,18 @@ begin
       end
     end
 
-    it "locates views defined in a custom namespace" do
+    test "locating views defined in a custom namespace" do
       template = Tilt::MustacheTemplate.new('bizzle.mustache', :namespace => Bar) { "<p>Hello World!</p>" }
       template.compile
-      template.engine.should.equal Bar::Views::Bizzle
-      template.render.should.equal "<p>Hello World!</p>"
+      assert_equal Bar::Views::Bizzle, template.engine
+      assert_equal "<p>Hello World!</p>", template.render
     end
 
-    it "copies instance variables from scope object" do
+    test "copying instance variables from scope object" do
       template = Tilt::MustacheTemplate.new('foo.mustache') { "<p>Hey {{foo}}!</p>" }
       scope = Object.new
       scope.instance_variable_set(:@foo, 'Jane!')
-      template.render(scope).should.equal "<p>Hey Jane!!</p>"
+      assert_equal "<p>Hey Jane!!</p>", template.render(scope)
     end
   end