tilt 1.1 → 1.2

data/README.md

@@ -38,6 +38,12 @@ Support for these template engines is included with the package:
     Nokogiri                   .nokogiri         nokogiri
     CoffeeScript               .coffee           coffee-script (+node coffee)
 
+These template engines ship with their own Tilt integration:
+
+    ENGINE                     FILE EXTENSIONS   REQUIRED LIBRARIES
+    -------------------------- ----------------- ----------------------------
+    Slim                       .slim             slim (>= 0.7)
+
 See [TEMPLATES.md][t] for detailed information on template engine
 options and supported features.
 
@@ -153,44 +159,13 @@ Or, use BlueCloth for markdown instead of RDiscount:
 Template Compilation
 --------------------
 
-Tilt can compile generated Ruby source code produced by template engines and
-reuse on subsequent template invocations. Benchmarks show this yields a 5x-10x
+Tilt compiles generated Ruby source code produced by template engines and reuses
+it on subsequent template invocations. Benchmarks show this yields a 5x-10x
 performance increase over evaluating the Ruby source on each invocation.
 
 Template compilation is currently supported for these template engines:
 StringTemplate, ERB, Erubis, Haml, and Builder.
 
-To enable template compilation, the `Tilt::CompileSite` module must be mixed in
-to the scope object passed to the template's `#render` method. This can be
-accomplished by including (with `Module#include`) the module in the class used
-for scope objects or by extending (with `Object#extend`) scope objects before
-passing to `Template#render`:
-
-    require 'tilt'
-
-    template = Tilt::ERBTemplate.new('foo.erb')
-
-    # Slow. Uses Object#instance_eval to process template
-    class Scope
-    end
-    scope = Scope.new
-    template.render(scope)
-
-    # Fast. Uses compiled template and Object#send to process template
-    class Scope
-      include Tilt::CompileSite
-    end
-    scope = Scope.new
-    template.render(scope)
-
-    # Also fast, though a bit a slower due to having to extend each time
-    scope = Object.new
-    scope.extend Tilt::CompileSite
-    template.render(scope)
-
-When the `Tilt::CompileSite` module is not present, template execution falls
-back to evaluating the template from source on each invocation.
-
 LICENSE
 -------
 

data/lib/tilt.rb

@@ -1,7 +1,6 @@
-require 'digest/md5'
-
 module Tilt
-  VERSION = '1.1'
+  TOPOBJECT = defined?(BasicObject) ? BasicObject : Object
+  VERSION = '1.2'
 
   @template_mappings = {}
 
@@ -42,19 +41,10 @@ module Tilt
     @template_mappings[pattern]
   end
 
-  # Mixin allowing template compilation on scope objects.
-  #
-  # Including this module in scope objects passed to Template#render
-  # causes template source to be compiled to methods the first time they're
-  # used. This can yield significant (5x-10x) performance increases for
-  # templates that support it (ERB, Erubis, Builder).
-  #
-  # It's also possible (though not recommended) to include this module in
-  # Object to enable template compilation globally. The downside is that
-  # the template methods will polute the global namespace and could lead to
-  # unexpected behavior.
+  # Deprecated module.
   module CompileSite
-    def __tilt__
+    def self.append_features(*)
+      warn "WARNING: Tilt::CompileSite is deprecated and will be removed in Tilt 2.0 (#{caller.first})."
     end
   end
 
@@ -111,12 +101,15 @@ module Tilt
         self.class.engine_initialized = true
       end
 
-      # used to generate unique method names for template compilation
-      @stamp = (Time.now.to_f * 10000).to_i
-      @compiled_method_names = {}
+      # used to hold compiled template methods
+      @compiled_method = {}
 
-      # load template data and prepare
-      @reader = block || lambda { |t| File.read(@file) }
+      # used on 1.9 to set the encoding if it is not set elsewhere (like a magic comment)
+      # currently only used if template compiles to ruby
+      @default_encoding = @options.delete :default_encoding
+
+      # load template data and prepare (uses binread to avoid encoding issues)
+      @reader = block || lambda { |t| File.respond_to?(:binread) ? File.binread(@file) : File.read(@file) }
       @data = @reader.call(self)
       prepare
     end
@@ -175,25 +168,21 @@ module Tilt
       end
     end
 
-    # Process the template and return the result. When the scope mixes in
-    # the Tilt::CompileSite module, the template is compiled to a method and
-    # reused given identical locals keys. When the scope object
-    # does not mix in the CompileSite module, the template source is
-    # evaluated with instance_eval. In any case, template executation
-    # is guaranteed to be performed in the scope object with the locals
-    # specified and with support for yielding to the block.
+    # Process the template and return the result. The first time this
+    # method is called, the template source is evaluated with instance_eval.
+    # On the sequential method calls it will compile the template to an
+    # unbound method which will lead to better performance. In any case,
+    # template executation is guaranteed to be performed in the scope object
+    # with the locals specified and with support for yielding to the block.
     def evaluate(scope, locals, &block)
-      if scope.respond_to?(:__tilt__)
-        method_name = compiled_method_name(locals.keys)
-        if scope.respond_to?(method_name)
-          scope.send(method_name, locals, &block)
-        else
-          compile_template_method(method_name, locals)
-          scope.send(method_name, locals, &block)
-        end
-      else
-        evaluate_source(scope, locals, &block)
+      # Redefine itself to use method compilation the next time:
+      def self.evaluate(scope, locals, &block)
+        method = compiled_method(locals.keys)
+        method.bind(scope).call(locals, &block)
       end
+
+      # Use instance_eval the first time:
+      evaluate_source(scope, locals, &block)
     end
 
     # Generates all template source by combining the preamble, template, and
@@ -207,9 +196,16 @@ module Tilt
     # easier and more appropriate.
     def precompiled(locals)
       preamble = precompiled_preamble(locals)
+      template = precompiled_template(locals)
+      magic_comment = extract_magic_comment(template)
+      if magic_comment
+        # Magic comment e.g. "# coding: utf-8" has to be in the first line.
+        # So we copy the magic comment to the first line.
+        preamble = magic_comment + "\n" + preamble
+      end
       parts = [
         preamble,
-        precompiled_template(locals),
+        template,
         precompiled_postamble(locals)
       ]
       [parts.join("\n"), preamble.count("\n") + 1]
@@ -241,10 +237,10 @@ module Tilt
       ''
     end
 
-    # The unique compiled method name for the locals keys provided.
-    def compiled_method_name(locals_keys)
-      @compiled_method_names[locals_keys] ||=
-        generate_compiled_method_name(locals_keys)
+    # The compiled method for the locals keys provided.
+    def compiled_method(locals_keys)
+      @compiled_method[locals_keys] ||=
+        compile_template_method(locals_keys)
     end
 
   private
@@ -274,42 +270,37 @@ module Tilt
       end
     end
 
-    def generate_compiled_method_name(locals_keys)
-      parts = [object_id, @stamp] + locals_keys.map { |k| k.to_s }.sort
-      digest = Digest::MD5.hexdigest(parts.join(':'))
-      "__tilt_#{digest}"
-    end
-
-    def compile_template_method(method_name, locals)
+    def compile_template_method(locals)
       source, offset = precompiled(locals)
       offset += 5
-      CompileSite.class_eval <<-RUBY, eval_file, line - offset
-        def #{method_name}(locals)
-          Thread.current[:tilt_vars] = [self, locals]
-          class << self
-            this, locals = Thread.current[:tilt_vars]
-            this.instance_eval do
-              #{source}
+      method_name = "__tilt_#{Thread.current.object_id.abs}"
+      Object.class_eval <<-RUBY, eval_file, line - offset
+        #{extract_magic_comment source}
+        TOPOBJECT.class_eval do
+          def #{method_name}(locals)
+            Thread.current[:tilt_vars] = [self, locals]
+            class << self
+              this, locals = Thread.current[:tilt_vars]
+              this.instance_eval do
+               #{source}
+              end
             end
           end
         end
       RUBY
-      ObjectSpace.define_finalizer self,
-        Template.compiled_template_method_remover(CompileSite, method_name)
+      unbind_compiled_method(method_name)
     end
 
-    def self.compiled_template_method_remover(site, method_name)
-      proc { |oid| garbage_collect_compiled_template_method(site, method_name) }
+    def unbind_compiled_method(method_name)
+      method = TOPOBJECT.instance_method(method_name)
+      TOPOBJECT.class_eval { remove_method(method_name) }
+      method
     end
 
-    def self.garbage_collect_compiled_template_method(site, method_name)
-      site.module_eval do
-        begin
-          remove_method(method_name)
-        rescue NameError
-          # method was already removed (ruby >= 1.9)
-        end
-      end
+    def extract_magic_comment(script)
+      comment = script.slice(/\A[ \t]*\#.*coding\s*[=:]\s*([[:alnum:]\-_]+).*$/)
+      return comment if comment and not %w[ascii-8bit binary].include?($1.downcase)
+      "# coding: #{@default_encoding}" if @default_encoding
     end
 
     # Special case Ruby 1.9.1's broken yield.
@@ -320,16 +311,18 @@ module Tilt
     # Remove when 1.9.2 dominates 1.9.1 installs in the wild.
     if RUBY_VERSION =~ /^1.9.1/
       undef compile_template_method
-      def compile_template_method(method_name, locals)
+      def compile_template_method(locals)
         source, offset = precompiled(locals)
         offset += 1
-        CompileSite.module_eval <<-RUBY, eval_file, line - offset
-          def #{method_name}(locals)
-            #{source}
+        method_name = "__tilt_#{Thread.current.object_id}"
+        Object.class_eval <<-RUBY, eval_file, line - offset
+          TOPOBJECT.class_eval do
+            def #{method_name}(locals)
+              #{source}
+            end
           end
         RUBY
-        ObjectSpace.define_finalizer self,
-          Template.compiled_template_method_remover(CompileSite, method_name)
+        unbind_compiled_method(method_name)
       end
     end
   end
@@ -635,6 +628,7 @@ module Tilt
       xml = ::Nokogiri::XML::Builder.new
       if data.respond_to?(:to_str)
         locals[:xml] = xml
+        block &&= proc { yield.gsub(/^<\?xml version=\"1\.0\"\?>\n?/, "") }
         super(scope, locals, &block)
       elsif data.kind_of?(Proc)
         data.call(xml)
@@ -744,6 +738,29 @@ module Tilt
   register 'md', RDiscountTemplate
 
 
+  # BlueCloth Markdown implementation. See:
+  # http://deveiate.org/projects/BlueCloth/
+  #
+  # RDiscount is a simple text filter. It does not support +scope+ or
+  # +locals+. The +:smartypants+ and +:escape_html+ options may be set true
+  # to enable those flags on the underlying BlueCloth object.
+  class BlueClothTemplate < Template
+    def initialize_engine
+      return if defined? ::BlueCloth
+      require_template_library 'bluecloth'
+    end
+
+    def prepare
+      @engine = BlueCloth.new(data, options)
+      @output = nil
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= @engine.to_html
+    end
+  end
+
+
   # RedCloth implementation. See:
   # http://redcloth.org/
   class RedClothTemplate < Template
@@ -849,16 +866,20 @@ module Tilt
       builder = self.class.builder_class.new({}, scope)
       builder.locals = locals
 
-      if block
+      if data.kind_of? Proc
+        (class << builder; self end).send(:define_method, :__run_markaby_tilt__, &data)
+      else
         builder.instance_eval <<-CODE, __FILE__, __LINE__
           def __run_markaby_tilt__
             #{data}
           end
         CODE
+      end
 
+      if block
         builder.__capture_markaby_tilt__(&block)
       else
-        builder.instance_eval(data, __FILE__, __LINE__)
+        builder.__run_markaby_tilt__
       end
 
       builder.to_s

data/test/tilt_blueclothtemplate_test.rb

@@ -0,0 +1,59 @@
+require 'contest'
+require 'tilt'
+
+begin
+  require 'bluecloth'
+
+  class BlueClothTemplateTest < Test::Unit::TestCase
+    setup do
+      Tilt.register('markdown', Tilt::BlueClothTemplate)
+      Tilt.register('md', Tilt::BlueClothTemplate)
+      Tilt.register('mkd', Tilt::BlueClothTemplate)
+    end
+    
+    teardown do
+      # Need to revert to RDiscount, otherwise the RDiscount test will fail
+      Tilt.register('markdown', Tilt::RDiscountTemplate)
+      Tilt.register('md', Tilt::RDiscountTemplate)
+      Tilt.register('mkd', Tilt::RDiscountTemplate)
+    end
+    
+    test "registered for '.markdown' files unless RDiscount is loaded" do
+      unless defined?(RDiscount)
+        assert_equal Tilt::BlueClothTemplate, Tilt['test.markdown']
+      end
+    end
+
+    test "registered for '.md' files unless RDiscount is loaded" do
+      unless defined?(RDiscount)
+        assert_equal Tilt::BlueClothTemplate, Tilt['test.md']
+      end
+    end
+
+    test "registered for '.mkd' files unless RDiscount is loaded" do
+      unless defined?(RDiscount)
+        assert_equal Tilt::BlueClothTemplate, Tilt['test.mkd']
+      end
+    end
+
+    test "preparing and evaluating templates on #render" do
+      template = Tilt::BlueClothTemplate.new { |t| "# Hello World!" }
+      assert_equal "<h1>Hello World!</h1>", template.render
+    end
+
+    test "smartypants when :smart is set" do
+      template = Tilt::BlueClothTemplate.new(:smartypants => true) { |t|
+        "OKAY -- 'Smarty Pants'" }
+      assert_equal "<p>OKAY &mdash; &lsquo;Smarty Pants&rsquo;</p>",
+        template.render
+    end
+
+    test "stripping HTML when :filter_html is set" do
+      template = Tilt::BlueClothTemplate.new(:escape_html => true) { |t|
+        "HELLO <blink>WORLD</blink>" }
+      assert_equal "<p>HELLO &lt;blink>WORLD&lt;/blink></p>", template.render
+    end
+  end
+rescue LoadError => boom
+  warn "Tilt::BlueClothTemplate (disabled)\n"
+end

data/test/tilt_coffeescripttemplate_test.rb

@@ -11,7 +11,7 @@ begin
 
     test "compiles and evaluates the template on #render" do
       template = Tilt::CoffeeScriptTemplate.new { |t| "puts 'Hello, World!'\n" }
-      assert_equal "(function() {\n  puts('Hello, World!');\n})();\n", template.render
+      assert_match "puts('Hello, World!');", template.render
     end
 
     test "disabling coffee-script wrapper" do

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
@@ -113,18 +115,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 +196,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_hamltemplate_test.rb

@@ -68,18 +68,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_markaby_test.rb

@@ -66,6 +66,16 @@ begin
     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

data/test/tilt_nokogiritemplate_test.rb

@@ -44,10 +44,19 @@ begin
         Tilt::NokogiriTemplate.new do |t|
           lambda { |xml| xml.em('Hey Joe!') }
         end
-      doc = Nokogiri.XML template.render template.render
+      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 }" }
+      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
 rescue LoadError
   warn "Tilt::NokogiriTemplate (disabled)"

data/test/tilt_stringtemplate_test.rb

@@ -74,18 +74,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,14 +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
-
-  test "template which accesses a constant with Tilt::CompileSite" do
-    flunk "known broken under 1.9.1" if RUBY_VERSION =~ /^1.9.1/
-    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.1'
-  s.date = '2010-09-10'
+  s.version = '1.2'
+  s.date = '2010-12-24'
 
   s.description = "Generic interface to multiple Ruby template engines"
   s.summary     = s.description
@@ -27,6 +27,7 @@ Gem::Specification.new do |s|
     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

metadata

@@ -1,12 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: tilt
 version: !ruby/object:Gem::Version 
-  hash: 13
+  hash: 11
   prerelease: false
   segments: 
   - 1
-  - 1
-  version: "1.1"
+  - 2
+  version: "1.2"
 platform: ruby
 authors: 
 - Ryan Tomayko
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-10 00:00:00 -07:00
+date: 2010-12-24 00:00:00 -08:00
 default_executable: tilt
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -195,6 +195,7 @@ files:
 - 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
@@ -255,6 +256,7 @@ signing_key:
 specification_version: 2
 summary: Generic interface to multiple Ruby template engines
 test_files: 
+- test/tilt_blueclothtemplate_test.rb
 - test/tilt_buildertemplate_test.rb
 - test/tilt_cache_test.rb
 - test/tilt_coffeescripttemplate_test.rb