tilt 1.0.1 → 1.2.2

data/test/tilt_compilesite_test.rb

@@ -17,48 +17,13 @@ class CompileSiteTest < Test::Unit::TestCase
   end
 
   class Scope
-    include Tilt::CompileSite
   end
 
   test "compiling template source to a method" do
     template = CompilingTemplate.new { |t| "Hello World!" }
     template.render(Scope.new)
-    method_name = template.send(:compiled_method_name, [])
-    method_name = method_name.to_sym if Symbol === Kernel.methods.first
-    assert Tilt::CompileSite.instance_methods.include?(method_name),
-      "CompileSite.instance_methods.include?(#{method_name.inspect})"
-    assert Scope.new.respond_to?(method_name),
-      "scope.respond_to?(#{method_name.inspect})"
-  end
-
-  test 'garbage collecting compiled methods' do
-    template = CompilingTemplate.new { '' }
-    method_name = template.send(:compiled_method_name, [])
-    template.render(Scope.new)
-    assert Scope.new.respond_to?(method_name)
-    Tilt::Template.send(
-      :garbage_collect_compiled_template_method,
-      Tilt::CompileSite,
-      method_name
-    )
-    assert !Scope.new.respond_to?(method_name), "compiled method not removed"
-  end
-
-  def self.create_and_destroy_template
-    template = CompilingTemplate.new { 'Hello World' }
-    template.render(Scope.new)
-    method_name = template.send(:compiled_method_name, [])
-    method_name = method_name.to_sym if Symbol === Kernel.methods.first
-    [template.object_id, method_name]
-  end
-
-  finalized_object_id, finalized_method_name = create_and_destroy_template
-
-  test "triggering compiled method gc finalizer" do
-    assert !Tilt::CompileSite.instance_methods.include?(finalized_method_name),
-      "CompileSite.instance_methods.include?(#{finalized_method_name.inspect})"
-    assert !Scope.new.respond_to?(finalized_method_name),
-      "Scope.new.respond_to?(#{finalized_method_name.inspect})"
+    method = template.send(:compiled_method, [])
+    assert_kind_of UnboundMethod, method
   end
 
   # This test attempts to surface issues with compiling templates from

data/test/tilt_erbtemplate_test.rb

@@ -1,6 +1,8 @@
+# coding: utf-8
 require 'contest'
 require 'tilt'
 require 'erb'
+require 'tempfile'
 
 class ERBTemplateTest < Test::Unit::TestCase
   test "registered for '.erb' files" do
@@ -17,6 +19,11 @@ class ERBTemplateTest < Test::Unit::TestCase
     assert_equal "Hello World!", template.render
   end
 
+  test "can be rendered more than once" do
+    template = Tilt::ERBTemplate.new { |t| "Hello World!" }
+    3.times { 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')
@@ -113,18 +120,13 @@ class CompiledERBTemplateTest < Test::Unit::TestCase
   end
 
   class Scope
-    include Tilt::CompileSite
   end
 
   test "compiling template source to a method" do
     template = Tilt::ERBTemplate.new { |t| "Hello World!" }
     template.render(Scope.new)
-    method_name = template.send(:compiled_method_name, [])
-    method_name = method_name.to_sym if Symbol === Kernel.methods.first
-    assert Tilt::CompileSite.instance_methods.include?(method_name),
-      "CompileSite.instance_methods.include?(#{method_name.inspect})"
-    assert Scope.new.respond_to?(method_name),
-      "scope.respond_to?(#{method_name.inspect})"
+    method = template.send(:compiled_method, [])
+    assert_kind_of UnboundMethod, method
   end
 
   test "loading and evaluating templates on #render" do
@@ -199,6 +201,27 @@ class CompiledERBTemplateTest < Test::Unit::TestCase
     template = Tilt.new('test.erb', :trim => '%') { "\n% if true\nhello\n%end\n" }
     assert_equal "\nhello\n", template.render(Scope.new)
   end
+
+  test "encoding with magic comment" do
+    f = Tempfile.open("template")
+    f.puts('<%# coding: UTF-8 %>')
+    f.puts('ふが <%= @hoge %>')
+    f.close()
+    @hoge = "ほげ"
+    erb = Tilt['erb'].new(f.path)
+    3.times { erb.render(self) }
+    f.delete
+  end
+
+  test "encoding with :default_encoding" do
+    f = Tempfile.open("template")
+    f.puts('ふが <%= @hoge %>')
+    f.close()
+    @hoge = "ほげ"
+    erb = Tilt['erb'].new(f.path, :default_encoding => 'UTF-8')
+    3.times { erb.render(self) }
+    f.delete
+  end
 end
 
 __END__

data/test/tilt_erubistemplate_test.rb

@@ -14,6 +14,11 @@ begin
       assert_equal "Hello World!", template.render
     end
 
+    test "can be rendered more than once" do
+      template = Tilt::ErubisTemplate.new { |t| "Hello World!" }
+      3.times { 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')

data/test/tilt_hamltemplate_test.rb

@@ -17,6 +17,11 @@ begin
       assert_equal "<p>Hello World!</p>\n", template.render
     end
 
+    test "can be rendered more than once" do
+      template = Tilt::HamlTemplate.new { |t| "%p Hello World!" }
+      3.times { assert_equal "<p>Hello World!</p>\n", template.render }
+    end
+
     test "passing locals" do
       template = Tilt::HamlTemplate.new { "%p= 'Hey ' + name + '!'" }
       assert_equal "<p>Hey Joe!</p>\n", template.render(Object.new, :name => 'Joe')
@@ -68,18 +73,13 @@ begin
 
   class CompiledHamlTemplateTest < Test::Unit::TestCase
     class Scope
-      include Tilt::CompileSite
     end
 
     test "compiling template source to a method" do
       template = Tilt::HamlTemplate.new { |t| "Hello World!" }
       template.render(Scope.new)
-      method_name = template.send(:compiled_method_name, [])
-      method_name = method_name.to_sym if Symbol === Kernel.methods.first
-      assert Tilt::CompileSite.instance_methods.include?(method_name),
-        "CompileSite.instance_methods.include?(#{method_name.inspect})"
-      assert Scope.new.respond_to?(method_name),
-        "scope.respond_to?(#{method_name.inspect})"
+      method = template.send(:compiled_method, [])
+      assert_kind_of UnboundMethod, method
     end
 
     test "passing locals" do

data/test/tilt_lesstemplate_test.rb

@@ -13,6 +13,11 @@ begin
       template = Tilt::LessTemplate.new { |t| ".bg { background-color: #0000ff; } \n#main\n { .bg; }\n" }
       assert_equal ".bg, #main { background-color: #0000ff; }\n", template.render
     end
+
+    test "can be rendered more than once" do
+      template = Tilt::LessTemplate.new { |t| ".bg { background-color: #0000ff; } \n#main\n { .bg; }\n" }
+      3.times { assert_equal ".bg, #main { background-color: #0000ff; }\n", template.render }
+    end
   end
 
 rescue LoadError => boom

data/test/tilt_liquidtemplate_test.rb

@@ -14,6 +14,11 @@ begin
       assert_equal "Hello World!", template.render
     end
 
+    test "can be rendered more than once" do
+      template = Tilt::LiquidTemplate.new { |t| "Hello World!" }
+      3.times { 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')

data/test/tilt_markaby_test.rb

@@ -0,0 +1,88 @@
+require 'contest'
+require 'tilt'
+
+begin
+  require 'markaby'
+
+  class MarkabyTiltTest <  Test::Unit::TestCase
+    def setup
+      @block = lambda do |t|
+        File.read(File.dirname(__FILE__) + "/#{t.file}")
+      end
+    end
+
+    test "should be able to render a markaby template with static html" do
+      tilt = Tilt::MarkabyTemplate.new("markaby/markaby.mab", &@block)
+      assert_equal "hello from markaby!", tilt.render
+    end
+
+    test "should use the contents of the template" do
+      tilt = ::Tilt::MarkabyTemplate.new("markaby/markaby_other_static.mab", &@block)
+      assert_equal "_why?", tilt.render
+    end
+
+    test "should render from a string (given as data)" do
+      tilt = ::Tilt::MarkabyTemplate.new { "html do; end" }
+      assert_equal "<html></html>", tilt.render
+    end
+
+    test "can be rendered more than once" do
+      tilt = ::Tilt::MarkabyTemplate.new { "html do; end" }
+      3.times { assert_equal "<html></html>", tilt.render }
+    end
+
+    test "should evaluate a template file in the scope given" do
+      scope = Object.new
+      def scope.foo
+        "bar"
+      end
+
+      tilt = ::Tilt::MarkabyTemplate.new("markaby/scope.mab", &@block)
+      assert_equal "<li>bar</li>", tilt.render(scope)
+    end
+
+    test "should pass locals to the template" do
+      tilt = ::Tilt::MarkabyTemplate.new("markaby/locals.mab", &@block)
+      assert_equal "<li>bar</li>", tilt.render(Object.new, { :foo => "bar" })
+    end
+
+    test "should yield to the block given" do
+      tilt = ::Tilt::MarkabyTemplate.new("markaby/yielding.mab", &@block)
+      eval_scope = Markaby::Builder.new
+
+      output = tilt.render(Object.new, {}) do
+        text("Joe")
+      end
+
+      assert_equal "Hey Joe", output
+    end
+
+    test "should be able to render two templates in a row" do
+      tilt = ::Tilt::MarkabyTemplate.new("markaby/render_twice.mab", &@block)
+
+      assert_equal "foo", tilt.render
+      assert_equal "foo", tilt.render
+    end
+
+    test "should retrieve a Tilt::MarkabyTemplate when calling Tilt['hello.mab']" do
+      assert_equal Tilt::MarkabyTemplate, ::Tilt['./markaby/markaby.mab']
+    end
+
+    test "should return a new instance of the implementation class (when calling Tilt.new)" do
+      assert ::Tilt.new(File.dirname(__FILE__) + "/markaby/markaby.mab").kind_of?(Tilt::MarkabyTemplate)
+    end
+
+    test "should be able to evaluate block style templates" do
+      tilt = Tilt::MarkabyTemplate.new { |t| lambda { h1 "Hello World!" }}
+      assert_equal "<h1>Hello World!</h1>", tilt.render
+    end
+
+    test "should pass locals to block style templates" do
+      tilt = Tilt::MarkabyTemplate.new { |t| lambda { h1 "Hello #{name}!" }}
+      assert_equal "<h1>Hello _why!</h1>", tilt.render(nil, :name => "_why")
+    end
+  end
+
+rescue LoadError => boom
+  warn "Tilt::MarkabyTemplate (disabled)\n"
+end

data/test/tilt_nokogiritemplate_test.rb

@@ -0,0 +1,76 @@
+require 'contest'
+require 'tilt'
+
+begin
+  require 'nokogiri'
+  class NokogiriTemplateTest < Test::Unit::TestCase
+    test "registered for '.nokogiri' files" do
+      assert_equal Tilt::NokogiriTemplate, Tilt['test.nokogiri']
+      assert_equal Tilt::NokogiriTemplate, Tilt['test.xml.nokogiri']
+    end
+
+    test "preparing and evaluating the template on #render" do
+      template = Tilt::NokogiriTemplate.new { |t| "xml.em 'Hello World!'" }
+      doc = Nokogiri.XML template.render
+      assert_equal 'Hello World!', doc.root.text
+      assert_equal 'em', doc.root.name
+    end
+
+    test "can be rendered more than once" do
+      template = Tilt::NokogiriTemplate.new { |t| "xml.em 'Hello World!'" }
+      3.times do
+        doc = Nokogiri.XML template.render
+        assert_equal 'Hello World!', doc.root.text
+        assert_equal 'em', doc.root.name
+      end
+    end
+
+    test "passing locals" do
+      template = Tilt::NokogiriTemplate.new { "xml.em('Hey ' + name + '!')" }
+      doc = Nokogiri.XML template.render(Object.new, :name => 'Joe')
+      assert_equal 'Hey Joe!', doc.root.text
+      assert_equal 'em', doc.root.name
+    end
+
+    test "evaluating in an object scope" do
+      template = Tilt::NokogiriTemplate.new { "xml.em('Hey ' + @name + '!')" }
+      scope = Object.new
+      scope.instance_variable_set :@name, 'Joe'
+      doc = Nokogiri.XML template.render(scope)
+      assert_equal 'Hey Joe!', doc.root.text
+      assert_equal 'em', doc.root.name
+    end
+
+    test "passing a block for yield" do
+      template = Tilt::NokogiriTemplate.new { "xml.em('Hey ' + yield + '!')" }
+      3.times do
+        doc = Nokogiri.XML template.render { 'Joe' }
+        assert_equal 'Hey Joe!', doc.root.text
+        assert_equal 'em', doc.root.name
+      end
+    end
+
+    test "block style templates" do
+      template =
+        Tilt::NokogiriTemplate.new do |t|
+          lambda { |xml| xml.em('Hey Joe!') }
+        end
+      doc = Nokogiri.XML template.render
+      assert_equal 'Hey Joe!', doc.root.text
+      assert_equal 'em', doc.root.name
+    end
+
+    test "allows nesting raw XML, API-compatible to Builder" do
+      subtemplate = Tilt::NokogiriTemplate.new { "xml.em 'Hello World!'" }
+      template = Tilt::NokogiriTemplate.new { "xml.strong { xml << yield }" }
+      3.times do
+        options = { :xml => Nokogiri::XML::Builder.new }
+        doc = Nokogiri.XML(template.render(options) { subtemplate.render(options) })
+        assert_equal 'Hello World!', doc.root.text.strip
+        assert_equal 'strong', doc.root.name
+      end
+    end
+  end
+rescue LoadError
+  warn "Tilt::NokogiriTemplate (disabled)"
+end

data/test/tilt_radiustemplate_test.rb

@@ -2,6 +2,10 @@ require 'contest'
 require 'tilt'
 
 begin
+  # 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"
+
   require 'radius'
 
   class RadiusTemplateTest < Test::Unit::TestCase
@@ -14,6 +18,11 @@ begin
       assert_equal "Hello World!", template.render
     end
 
+    test "can be rendered more than once" do
+      template = Tilt::RadiusTemplate.new { |t| "Hello World!" }
+      3.times { assert_equal "Hello World!", template.render }
+    end
+
     test "passing locals" do
       template = Tilt::RadiusTemplate.new { "Hey <r:name />!" }
       assert_equal "Hey Joe!", template.render(nil, :name => 'Joe')

data/test/tilt_rdiscounttemplate_test.rb

@@ -22,6 +22,11 @@ begin
       assert_equal "<h1>Hello World!</h1>\n", template.render
     end
 
+    test "can be rendered more than once" do
+      template = Tilt::RDiscountTemplate.new { |t| "# Hello World!" }
+      3.times { assert_equal "<h1>Hello World!</h1>\n", template.render }
+    end
+
     test "smartypants when :smart is set" do
       template = Tilt::RDiscountTemplate.new(:smart => true) { |t|
         "OKAY -- 'Smarty Pants'" }

data/test/tilt_rdoctemplate_test.rb

@@ -11,7 +11,12 @@ begin
 
     test "preparing and evaluating the template with #render" do
       template = Tilt::RDocTemplate.new { |t| "= Hello World!" }
-      assert_equal "<h1>Hello World!</h1>\n", template.render
+      assert_equal "<h1>Hello World!</h1>", template.render.strip
+    end
+
+    test "can be rendered more than once" do
+      template = Tilt::RDocTemplate.new { |t| "= Hello World!" }
+      3.times { assert_equal "<h1>Hello World!</h1>", template.render.strip }
     end
   end
 rescue LoadError => boom

data/test/tilt_redclothtemplate_test.rb

@@ -14,6 +14,10 @@ begin
       assert_equal "<h1>Hello World!</h1>", template.render
     end
 
+    test "can be rendered more than once" do
+      template = Tilt::RedClothTemplate.new { |t| "h1. Hello World!" }
+      3.times { assert_equal "<h1>Hello World!</h1>", template.render }
+    end
   end
 rescue LoadError => boom
   warn "Tilt::RedClothTemplate (disabled)\n"

data/test/tilt_sasstemplate_test.rb

@@ -14,6 +14,27 @@ begin
       template = Tilt::SassTemplate.new { |t| "#main\n  :background-color #0000f1" }
       assert_equal "#main {\n  background-color: #0000f1; }\n", template.render
     end
+
+    test "can be rendered more than once" do
+      template = Tilt::SassTemplate.new { |t| "#main\n  :background-color #0000f1" }
+      3.times { assert_equal "#main {\n  background-color: #0000f1; }\n", template.render }
+    end
+  end
+
+  class ScssTemplateTest < Test::Unit::TestCase
+    test "is registered for '.scss' files" do
+      assert_equal Tilt::ScssTemplate, Tilt['test.scss']
+    end
+
+    test "compiles and evaluates the template on #render" do
+      template = Tilt::ScssTemplate.new { |t| "#main {\n  background-color: #0000f1;\n}" }
+      assert_equal "#main {\n  background-color: #0000f1; }\n", template.render
+    end
+
+    test "can be rendered more than once" do
+      template = Tilt::ScssTemplate.new { |t| "#main {\n  background-color: #0000f1;\n}" }
+      3.times { assert_equal "#main {\n  background-color: #0000f1; }\n", template.render }
+    end
   end
 
 rescue LoadError => boom

data/test/tilt_stringtemplate_test.rb

@@ -11,6 +11,11 @@ class StringTemplateTest < Test::Unit::TestCase
     assert_equal "Hello World!", template.render
   end
 
+  test "can be rendered more than once" do
+    template = Tilt::StringTemplate.new { |t| "Hello World!" }
+    3.times { assert_equal "Hello World!", template.render }
+  end
+
   test "passing locals" do
     template = Tilt::StringTemplate.new { 'Hey #{name}!' }
     assert_equal "Hey Joe!", template.render(Object.new, :name => 'Joe')
@@ -74,18 +79,13 @@ class CompiledStringTemplateTest < Test::Unit::TestCase
   end
 
   class Scope
-    include Tilt::CompileSite
   end
 
   test "compiling template source to a method" do
     template = Tilt::StringTemplate.new { |t| "Hello World!" }
     template.render(Scope.new)
-    method_name = template.send(:compiled_method_name, [])
-    method_name = method_name.to_sym if Symbol === Kernel.methods.first
-    assert Tilt::CompileSite.instance_methods.include?(method_name),
-      "CompileSite.instance_methods.include?(#{method_name.inspect})"
-    assert Scope.new.respond_to?(method_name),
-      "scope.respond_to?(#{method_name.inspect})"
+    method = template.send(:compiled_method, [])
+    assert_kind_of UnboundMethod, method
   end
 
   test "loading and evaluating templates on #render" do

data/test/tilt_template_test.rb

@@ -145,15 +145,4 @@ class TiltTemplateTest < Test::Unit::TestCase
     inst = SourceGeneratingMockTemplate.new { |t| 'Hey #{CONSTANT}!' }
     assert_equal "Hey Bob!", inst.render(Person.new("Joe"))
   end
-
-  class FastPerson < Person
-    include Tilt::CompileSite
-  end
-
-  # FAILING CONSTANT TEST. DISABLED FOR 1.0.
-
-  # test "template which accesses a constant with Tilt::CompileSite" do
-  #   inst = SourceGeneratingMockTemplate.new { |t| 'Hey #{CONSTANT}!' }
-  #   assert_equal "Hey Bob!", inst.render(FastPerson.new("Joe"))
-  # end
 end

data/tilt.gemspec

@@ -3,8 +3,8 @@ Gem::Specification.new do |s|
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
 
   s.name = 'tilt'
-  s.version = '1.0.1'
-  s.date = '2010-06-15'
+  s.version = '1.2.2'
+  s.date = '2011-01-17'
 
   s.description = "Generic interface to multiple Ruby template engines"
   s.summary     = s.description
@@ -21,14 +21,24 @@ Gem::Specification.new do |s|
     bin/tilt
     lib/tilt.rb
     test/contest.rb
+    test/markaby/locals.mab
+    test/markaby/markaby.mab
+    test/markaby/markaby_other_static.mab
+    test/markaby/render_twice.mab
+    test/markaby/scope.mab
+    test/markaby/yielding.mab
+    test/tilt_blueclothtemplate_test.rb
     test/tilt_buildertemplate_test.rb
     test/tilt_cache_test.rb
+    test/tilt_coffeescripttemplate_test.rb
     test/tilt_compilesite_test.rb
     test/tilt_erbtemplate_test.rb
     test/tilt_erubistemplate_test.rb
     test/tilt_hamltemplate_test.rb
     test/tilt_lesstemplate_test.rb
     test/tilt_liquidtemplate_test.rb
+    test/tilt_markaby_test.rb
+    test/tilt_nokogiritemplate_test.rb
     test/tilt_radiustemplate_test.rb
     test/tilt_rdiscounttemplate_test.rb
     test/tilt_rdoctemplate_test.rb
@@ -53,6 +63,9 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'liquid'
   s.add_development_dependency 'less'
   s.add_development_dependency 'radius'
+  s.add_development_dependency 'nokogiri'
+  s.add_development_dependency 'markaby'
+  s.add_development_dependency 'coffee-script'
 
   s.extra_rdoc_files = %w[COPYING]