tilt 0.7 → 0.8

data/COPYING

@@ -1,4 +1,4 @@
-Copyright (c) 2009 Ryan Tomayko <http://tomayko.com/about>
+Copyright (c) 2010 Ryan Tomayko <http://tomayko.com/about>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to

data/README.md

@@ -13,7 +13,8 @@ feature is relevant to the engine):
  * Ability to pass locals to template evaluation
  * Support for passing a block to template evaluation for "yield"
  * Backtraces with correct filenames and line numbers
- * Template compilation caching and reloading
+ * Template file caching and reloading
+ * Fast, method-based template source compilation
 
 The primary goal is to get all of the things listed above right for all
 template engines included in the distribution.
@@ -145,8 +146,49 @@ Or, use BlueCloth for markdown instead of RDiscount:
 
     Tilt.register 'markdown', Tilt::BlueClothTemplate
 
+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
+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
 -------
 
-Tilt is Copyright (c) 2009 [Ryan Tomayko](http://tomayko.com/about) and
-distributed under the MIT license. See the COPYING file for more info.
+Tilt is Copyright (c) 2010 [Ryan Tomayko](http://tomayko.com/about) and
+distributed under the MIT license. See the `COPYING` file for more info.

data/bin/tilt

@@ -3,17 +3,21 @@ require 'ostruct'
 require 'optparse'
 require 'tilt'
 
-usage = <<EOF
-Usage: tilt [OPTIONS] [FILE]
-Process template FILE and generate output. With no FILE or when FILE
-is '-', read template from stdin and use the --type option to determine
-the template's type.
+usage = <<USAGE
+Usage: tilt <options> <file>
+Process template <file> and write output to stdout. With no <file> or
+when <file> is '-', read template from stdin and use the --type option
+to determine the template's type.
 
 Options
-  -l, --list           List supported template engines + file patterns and exit.
-  -t, --type=PATTERN   Use this template engine; required when FILE is stdin.
+  -l, --list           List template engines + file patterns and exit
+  -t, --type=<pattern> Use this template engine; required if no <file>
+  -y, --layout=<file>  Use <file> as a layout template
 
-  -h, --help           Show this help message.
+  -D<name>=<value>     Define variable <name> as <value>
+  -o, --vars=<ruby>    Evaluate <ruby> to Hash and use for variables
+
+  -h, --help           Show this help message
 
 Convert markdown to HTML:
   $ tilt foo.markdown > foo.html
@@ -21,11 +25,18 @@ Convert markdown to HTML:
 Process ERB template:
   $ echo "Answer: <%= 2 + 2 %>" | tilt -t erb
   Answer: 4
-EOF
+
+Define variables:
+  $ echo "Answer: <%= 2 + n %>" | tilt --locals="{:n=>40, :x=>0}"
+  Answer: 42
+  $ echo "Answer: <%= 2 + n %>" | tilt -Dn=40 -Dx=0
+  Answer: 42
+USAGE
 
 script_name = File.basename($0)
 pattern = nil
 layout = nil
+locals = {}
 
 ARGV.options do |o|
   o.program_name = script_name
@@ -44,18 +55,31 @@ ARGV.options do |o|
   end
 
   # the template type / pattern
-  o.on("-t", "--type=PATTERN") do |val|
-    fail "unknown template type: #{val}" if Tilt[val].nil?
+  o.on("-t", "--type=PATTERN", String) do |val|
+    abort "unknown template type: #{val}" if Tilt[val].nil?
     pattern = val
   end
 
   # pass template output into the specified layout template
-  o.on("-y", "--layout=FILE")  do |file|
+  o.on("-y", "--layout=FILE", String)  do |file|
     paths = [file, "~/.tilt/#{file}", "/etc/tilt/#{file}"]
     layout = paths.
       map  { |p| File.expand_path(p) }.
       find { |p| File.exist?(p) }
-    fail "no such layout: #{file}" if layout.nil?
+    abort "no such layout: #{file}" if layout.nil?
+  end
+
+  # define a local variable
+  o.on("-D", "--define=PAIR", String) do |pair|
+    key, value = pair.split(/[=:]/, 2)
+    locals[key.to_sym] = value
+  end
+
+  # define local variables using a Ruby hash
+  o.on("--vars=RUBY") do |ruby|
+    hash = eval(ruby)
+    abort "vars must be a Hash, not #{hash.inspect}" if !hash.is_a?(Hash)
+    hash.each { |key, value| locals[key.to_sym] = value }
   end
 
   o.on_tail("-h", "--help") { puts usage; exit }
@@ -65,17 +89,22 @@ end
 
 file = ARGV.first || '-'
 pattern = file if pattern.nil?
+abort "template type not given. see: #{$0} --help" if ['-', ''].include?(pattern)
+
+engine = Tilt[pattern]
+abort "template engine not found for: #{pattern}" if engine.nil?
+
 template =
-  Tilt[pattern].new(file) {
+  engine.new(file) {
     if file == '-'
       $stdin.read
     else
       File.read(file)
     end
   }
-output = template.render
+output = template.render(self, locals)
 
 # process layout
-output = Tilt.new(layout).render { output } if layout
+output = Tilt.new(layout).render(self, locals) { output } if layout
 
 $stdout.write(output)

data/lib/tilt.rb

@@ -1,5 +1,7 @@
+require 'digest/md5'
+
 module Tilt
-  VERSION = '0.7'
+  VERSION = '0.8'
 
   @template_mappings = {}
 
@@ -113,8 +115,8 @@ module Tilt
       end
 
       # used to generate unique method names for template compilation
-      stamp = (Time.now.to_f * 10000).to_i
-      @_prefix = "__tilt_O#{object_id.to_s(16)}T#{stamp.to_s(16)}"
+      @stamp = (Time.now.to_f * 10000).to_i
+      @compiled_method_names = {}
 
       # load template data and prepare
       @reader = block || lambda { |t| File.read(@file) }
@@ -151,6 +153,16 @@ module Tilt
     def initialize_engine
     end
 
+    # Like Kernel::require but issues a warning urging a manual require when
+    # running under a threaded environment.
+    def require_template_library(name)
+      if Thread.list.size > 1
+        warn "WARN: tilt autoloading '#{name}' in a non thread-safe way; " +
+             "explicit require '#{name}' suggested."
+      end
+      require name
+    end
+
     # Do whatever preparation is necessary to setup the underlying template
     # engine. Called immediately after template data is loaded. Instance
     # variables set in this method are available when #evaluate is called.
@@ -175,54 +187,111 @@ module Tilt
     # 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.hash)
+        method_name = compiled_method_name(locals.keys)
         if scope.respond_to?(method_name)
-          # fast path
-          scope.send method_name, locals, &block
+          scope.send(method_name, locals, &block)
         else
-          # compile first and then run
           compile_template_method(method_name, locals)
-          scope.send method_name, locals, &block
+          scope.send(method_name, locals, &block)
         end
       else
-        source, offset = local_assignment_code(locals)
-        source = [source, template_source].join("\n")
-        scope.instance_eval source, eval_file, line - offset
+        evaluate_source(scope, locals, &block)
       end
     end
 
-    # Return a string containing the (Ruby) source code for the template. The
-    # default Template#evaluate implementation requires this method be
-    # defined and guarantees correct file/line handling, custom scopes, and
-    # support for template compilation when the scope object allows it.
-    def template_source
+    # Generates all template source by combining the preamble, template, and
+    # postamble and returns a two-tuple of the form: [source, offset], where
+    # source is the string containing (Ruby) source code for the template and
+    # offset is the integer line offset where line reporting should begin.
+    #
+    # Template subclasses may override this method when they need complete
+    # control over source generation or want to adjust the default line
+    # offset. In most cases, overriding the #precompiled_template method is
+    # easier and more appropriate.
+    def precompiled(locals)
+      preamble = precompiled_preamble(locals)
+      parts = [
+        preamble,
+        precompiled_template(locals),
+        precompiled_postamble(locals)
+      ]
+      [parts.join("\n"), preamble.count("\n") + 1]
+    end
+
+    # A string containing the (Ruby) source code for the template. The
+    # default Template#evaluate implementation requires either this method
+    # or the #precompiled method be overridden. When defined, the base
+    # Template guarantees correct file/line handling, locals support, custom
+    # scopes, and support for template compilation when the scope object
+    # allows it.
+    def precompiled_template(locals)
       raise NotImplementedError
     end
 
+    # Generates preamble code for initializing template state, and performing
+    # locals assignment. The default implementation performs locals
+    # assignment only. Lines included in the preamble are subtracted from the
+    # source line offset, so adding code to the preamble does not effect line
+    # reporting in Kernel::caller and backtraces.
+    def precompiled_preamble(locals)
+      locals.map { |k,v| "#{k} = locals[:#{k}]" }.join("\n")
+    end
+
+    # Generates postamble code for the precompiled template source. The
+    # string returned from this method is appended to the precompiled
+    # template source.
+    def precompiled_postamble(locals)
+      ''
+    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)
+    end
+
   private
-    def local_assignment_code(locals)
-      return ['', 1] if locals.empty?
-      source = locals.collect { |k,v| "#{k} = locals[:#{k}]" }
-      [source.join("\n"), source.length]
+    # Evaluate the template source in the context of the scope object.
+    def evaluate_source(scope, locals, &block)
+      source, offset = precompiled(locals)
+      scope.instance_eval(source, eval_file, line - offset)
     end
 
-    def compiled_method_name(locals_hash)
-      "#{@_prefix}L#{locals_hash.to_s(16).sub('-', 'n')}"
+    # JRuby doesn't allow Object#instance_eval to yield to the block it's
+    # closed over. This is by design and (ostensibly) something that will
+    # change in MRI, though no current MRI version tested (1.8.6 - 1.9.2)
+    # exhibits the behavior. More info here:
+    #
+    # http://jira.codehaus.org/browse/JRUBY-2599
+    #
+    # Additionally, JRuby's eval line reporting is off by one compared to
+    # all MRI versions tested.
+    #
+    # We redefine evaluate_source to work around both issues.
+    if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+      undef evaluate_source
+      def evaluate_source(scope, locals, &block)
+        source, offset = precompiled(locals)
+        file, lineno = eval_file, (line - offset) - 1
+        scope.instance_eval { Kernel::eval(source, binding, file, lineno) }
+      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)
-      source, offset = local_assignment_code(locals)
-      source = [source, template_source].join("\n")
+      source, offset = precompiled(locals)
       offset += 1
-
-      # add the new method
       CompileSite.module_eval <<-RUBY, eval_file, line - offset
         def #{method_name}(locals)
           #{source}
         end
       RUBY
 
-      # setup a finalizer to remove the newly added method
       ObjectSpace.define_finalizer self,
         Template.compiled_template_method_remover(CompileSite, method_name)
     end
@@ -240,14 +309,6 @@ module Tilt
         end
       end
     end
-
-    def require_template_library(name)
-      if Thread.list.size > 1
-        warn "WARN: tilt autoloading '#{name}' in a non thread-safe way; " +
-             "explicit require '#{name}' suggested."
-      end
-      require name
-    end
   end
 
   # Extremely simple template cache implementation. Calling applications
@@ -282,7 +343,7 @@ module Tilt
       @code = "%Q{#{data}}"
     end
 
-    def template_source
+    def precompiled_template(locals)
       @code
     end
   end
@@ -293,7 +354,8 @@ module Tilt
   # http://www.ruby-doc.org/stdlib/libdoc/erb/rdoc/classes/ERB.html
   class ERBTemplate < Template
     def initialize_engine
-      require_template_library 'erb' unless defined? ::ERB
+      return if defined? ::ERB
+      require_template_library 'erb'
     end
 
     def prepare
@@ -301,38 +363,37 @@ module Tilt
       @engine = ::ERB.new(data, options[:safe], options[:trim], @outvar)
     end
 
-    def template_source
+    def precompiled_template(locals)
       @engine.src
     end
 
-    def evaluate(scope, locals, &block)
-      preserve_outvar_value(scope) { super }
+    def precompiled_preamble(locals)
+      <<-RUBY
+        begin
+          __original_outvar = #{@outvar} if defined?(#{@outvar})
+          #{super}
+      RUBY
     end
 
-  private
-    # Retains the previous value of outvar when configured to use
-    # an instance variable. This allows multiple templates to be rendered
-    # within the context of an object without overwriting the outvar.
-    def preserve_outvar_value(scope)
-      if @outvar[0] == ?@
-        previous = scope.instance_variable_get(@outvar)
-        output = yield
-        scope.instance_variable_set(@outvar, previous)
-        output
-      else
-        yield
-      end
+    def precompiled_postamble(locals)
+      <<-RUBY
+          #{super}
+        ensure
+          #{@outvar} = __original_outvar
+        end
+      RUBY
     end
 
     # ERB generates a line to specify the character coding of the generated
     # source in 1.9. Account for this in the line offset.
     if RUBY_VERSION >= '1.9.0'
-      def local_assignment_code(locals)
+      def precompiled(locals)
         source, offset = super
         [source, offset + 1]
       end
     end
   end
+
   %w[erb rhtml].each { |ext| register ext, ERBTemplate }
 
 
@@ -340,7 +401,8 @@ module Tilt
   # http://www.kuwata-lab.com/erubis/
   class ErubisTemplate < ERBTemplate
     def initialize_engine
-      require_template_library 'erubis' unless defined? ::Erubis
+      return if defined? ::Erubis
+      require_template_library 'erubis'
     end
 
     def prepare
@@ -349,15 +411,18 @@ module Tilt
       @engine = ::Erubis::Eruby.new(data, options)
     end
 
-    def template_source
-      ["#{@outvar} = _buf = ''", @engine.src, "_buf.to_s"].join(";")
+    def precompiled_preamble(locals)
+      [super, "#{@outvar} = _buf = ''"].join("\n")
     end
 
-  private
-    # Erubis doesn't have ERB's line-off-by-one under 1.9 problem. Override
-    # and adjust back.
+    def precompiled_postamble(locals)
+      ["_buf", super].join("\n")
+    end
+
+    # Erubis doesn't have ERB's line-off-by-one under 1.9 problem.
+    # Override and adjust back.
     if RUBY_VERSION >= '1.9.0'
-      def local_assignment_code(locals)
+      def precompiled(locals)
         source, offset = super
         [source, offset - 1]
       end
@@ -370,26 +435,48 @@ module Tilt
   # http://haml.hamptoncatlin.com/
   class HamlTemplate < Template
     def initialize_engine
-      require_template_library 'haml' unless defined? ::Haml::Engine
+      return if defined? ::Haml::Engine
+      require_template_library 'haml'
     end
 
     def prepare
-      @engine = ::Haml::Engine.new(data, haml_options)
+      options = @options.merge(:filename => eval_file, :line => line)
+      @engine = ::Haml::Engine.new(data, options)
+    end
+
+    def evaluate(scope, locals, &block)
+      if @engine.respond_to?(:precompiled_method_return_value, true)
+        super
+      else
+        @engine.render(scope, locals, &block)
+      end
     end
 
     # Precompiled Haml source. Taken from the precompiled_with_ambles
     # method in Haml::Precompiler:
     # http://github.com/nex3/haml/blob/master/lib/haml/precompiler.rb#L111-126
-    def template_source
+    def precompiled_template(locals)
+      @engine.precompiled
+    end
+
+    def precompiled_preamble(locals)
+      local_assigns = super
       @engine.instance_eval do
         <<-RUBY
-          _haml_locals = locals
           begin
             extend Haml::Helpers
             _hamlout = @haml_buffer = Haml::Buffer.new(@haml_buffer, #{options_for_buffer.inspect})
             _erbout = _hamlout.buffer
             __in_erb_template = true
-            #{precompiled}
+            _haml_locals = locals
+            #{local_assigns}
+        RUBY
+      end
+    end
+
+    def precompiled_postamble(locals)
+      @engine.instance_eval do
+        <<-RUBY
             #{precompiled_method_return_value}
           ensure
             @haml_buffer = @haml_buffer.upper
@@ -397,16 +484,6 @@ module Tilt
         RUBY
       end
     end
-
-  private
-    def local_assignment_code(locals)
-      source, offset = super
-      [source, offset + 6]
-    end
-
-    def haml_options
-      options.merge(:filename => eval_file, :line => line)
-    end
   end
   register 'haml', HamlTemplate
 
@@ -417,7 +494,8 @@ module Tilt
   # Sass templates do not support object scopes, locals, or yield.
   class SassTemplate < Template
     def initialize_engine
-      require_template_library 'sass' unless defined? ::Sass::Engine
+      return if defined? ::Sass::Engine
+      require_template_library 'sass'
     end
 
     def prepare
@@ -442,7 +520,8 @@ module Tilt
   # Less templates do not support object scopes, locals, or yield.
   class LessTemplate < Template
     def initialize_engine
-      require_template_library 'less' unless defined? ::Less::Engine
+      return if defined? ::Less::Engine
+      require_template_library 'less'
     end
 
     def prepare
@@ -460,7 +539,8 @@ module Tilt
   # http://builder.rubyforge.org/
   class BuilderTemplate < Template
     def initialize_engine
-      require_template_library 'builder' unless defined?(::Builder)
+      return if defined?(::Builder)
+      require_template_library 'builder'
     end
 
     def prepare
@@ -477,7 +557,7 @@ module Tilt
       xml.target!
     end
 
-    def template_source
+    def precompiled_template(locals)
       data.to_str
     end
   end
@@ -499,7 +579,8 @@ module Tilt
   # time when using this template engine.
   class LiquidTemplate < Template
     def initialize_engine
-      require_template_library 'liquid' unless defined? ::Liquid::Template
+      return if defined? ::Liquid::Template
+      require_template_library 'liquid'
     end
 
     def prepare
@@ -532,15 +613,17 @@ module Tilt
     end
 
     def initialize_engine
-      require_template_library 'rdiscount' unless defined? ::RDiscount
+      return if defined? ::RDiscount
+      require_template_library 'rdiscount'
     end
 
     def prepare
       @engine = RDiscount.new(data, *flags)
+      @output = nil
     end
 
     def evaluate(scope, locals, &block)
-      @engine.to_html
+      @output ||= @engine.to_html
     end
   end
   register 'markdown', RDiscountTemplate
@@ -552,15 +635,17 @@ module Tilt
   # http://redcloth.org/
   class RedClothTemplate < Template
     def initialize_engine
-      require_template_library 'redcloth' unless defined? ::RedCloth
+      return if defined? ::RedCloth
+      require_template_library 'redcloth'
     end
 
     def prepare
       @engine = RedCloth.new(data)
+      @output = nil
     end
 
     def evaluate(scope, locals, &block)
-      @engine.to_html
+      @output ||= @engine.to_html
     end
   end
   register 'textile', RedClothTemplate
@@ -576,7 +661,8 @@ module Tilt
     attr_reader :engine
 
     def initialize_engine
-      require_template_library 'mustache' unless defined? ::Mustache
+      return if defined? ::Mustache
+      require_template_library 'mustache'
     end
 
     def prepare
@@ -622,19 +708,19 @@ module Tilt
   # engine.
   class RDocTemplate < Template
     def initialize_engine
-      unless defined?(::RDoc::Markup)
-        require_template_library 'rdoc/markup'
-        require_template_library 'rdoc/markup/to_html'
-      end
+      return if defined?(::RDoc::Markup)
+      require_template_library 'rdoc/markup'
+      require_template_library 'rdoc/markup/to_html'
     end
 
     def prepare
       markup = RDoc::Markup::ToHtml.new
       @engine = markup.convert(data)
+      @output = nil
     end
 
     def evaluate(scope, locals, &block)
-      @engine.to_s
+      @output ||= @engine.to_s
     end
   end
   register 'rdoc', RDocTemplate
@@ -644,15 +730,16 @@ module Tilt
   # http://jashkenas.github.com/coffee-script/
   class CoffeeTemplate < Template
     def initialize_engine
-      require_template_library 'coffee-script' unless defined? ::CoffeeScript
+      return if defined? ::CoffeeScript
+      require_template_library 'coffee-script'
     end
 
     def prepare
-      @engine = ::CoffeeScript::compile(data, options)
+      @output = nil
     end
 
     def evaluate(scope, locals, &block)
-      @engine
+      @output ||= ::CoffeeScript::compile(data, options)
     end
   end
   register 'coffee', CoffeeTemplate

data/test/tilt_compilesite_test.rb

@@ -1,5 +1,6 @@
 require 'contest'
 require 'tilt'
+require 'thread'
 
 class CompileSiteTest < Test::Unit::TestCase
   def setup
@@ -10,7 +11,7 @@ class CompileSiteTest < Test::Unit::TestCase
     def prepare
     end
 
-    def template_source
+    def precompiled_template(locals)
       @data.inspect
     end
   end
@@ -22,7 +23,7 @@ class CompileSiteTest < Test::Unit::TestCase
   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, [].hash)
+    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})"
@@ -32,7 +33,7 @@ class CompileSiteTest < Test::Unit::TestCase
 
   test 'garbage collecting compiled methods' do
     template = CompilingTemplate.new { '' }
-    method_name = template.send(:compiled_method_name, [].hash)
+    method_name = template.send(:compiled_method_name, [])
     template.render(Scope.new)
     assert Scope.new.respond_to?(method_name)
     Tilt::Template.send(
@@ -46,7 +47,7 @@ class CompileSiteTest < Test::Unit::TestCase
   def self.create_and_destroy_template
     template = CompilingTemplate.new { 'Hello World' }
     template.render(Scope.new)
-    method_name = template.send(:compiled_method_name, [].hash)
+    method_name = template.send(:compiled_method_name, [])
     method_name = method_name.to_sym if Symbol === Kernel.methods.first
     [template.object_id, method_name]
   end
@@ -59,4 +60,27 @@ class CompileSiteTest < Test::Unit::TestCase
     assert !Scope.new.respond_to?(finalized_method_name),
       "Scope.new.respond_to?(#{finalized_method_name.inspect})"
   end
+
+  # This test attempts to surface issues with compiling templates from
+  # multiple threads.
+  test "using compiled templates from multiple threads" do
+    template = CompilingTemplate.new { 'template' }
+    main_thread = Thread.current
+    10.times do |i|
+      threads =
+        (1..50).map do |j|
+          Thread.new {
+            begin
+              locals = { "local#{i}" => 'value' }
+              res = template.render(self, locals)
+              thread_id = Thread.current.object_id
+              res = template.render(self, "local#{thread_id.to_s}" => 'value')
+            rescue => boom
+              main_thread.raise(boom)
+            end
+          }
+        end
+      threads.each { |t| t.join }
+    end
+  end
 end

data/test/tilt_erbtemplate_test.rb

@@ -102,7 +102,7 @@ class CompiledERBTemplateTest < Test::Unit::TestCase
   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, [].hash)
+    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})"

data/test/tilt_hamltemplate_test.rb

@@ -71,6 +71,17 @@ begin
       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})"
+    end
+
     test "passing locals" do
       template = Tilt::HamlTemplate.new { "%p= 'Hey ' + name + '!'" }
       assert_equal "<p>Hey Joe!</p>\n", template.render(Scope.new, :name => 'Joe')

data/test/tilt_stringtemplate_test.rb

@@ -80,7 +80,7 @@ class CompiledStringTemplateTest < Test::Unit::TestCase
   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, [].hash)
+    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})"

data/test/tilt_template_test.rb

@@ -110,7 +110,7 @@ class TiltTemplateTest < Test::Unit::TestCase
   end
 
   class SourceGeneratingMockTemplate < PreparingMockTemplate
-    def template_source
+    def precompiled_template(locals)
       "foo = [] ; foo << %Q{#{data}} ; foo.join"
     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 = '0.7'
-  s.date = '2010-03-04'
+  s.version = '0.8'
+  s.date = '2010-03-07'
 
   s.description = "Generic interface to multiple Ruby template engines"
   s.summary     = s.description
@@ -42,11 +42,11 @@ Gem::Specification.new do |s|
   ]
   # = MANIFEST =
 
-  s.test_files = s.files.select {|path| path =~ /^test\/spec_.*.rb/}
+  s.test_files = s.files.select {|path| path =~ /^test\/.*_test.rb/}
   s.add_development_dependency 'contest'
   s.add_development_dependency 'builder'
   s.add_development_dependency 'erubis'
-  s.add_development_dependency 'haml'
+  s.add_development_dependency 'haml', '>= 2.2.11'
   s.add_development_dependency 'mustache'
   s.add_development_dependency 'rdiscount'
   s.add_development_dependency 'liquid'

metadata

@@ -4,8 +4,8 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 7
-  version: "0.7"
+  - 8
+  version: "0.8"
 platform: ruby
 authors: 
 - Ryan Tomayko
@@ -13,7 +13,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-04 00:00:00 -08:00
+date: 2010-03-07 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -60,8 +60,10 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version 
         segments: 
-        - 0
-        version: "0"
+        - 2
+        - 2
+        - 11
+        version: 2.2.11
   type: :development
   version_requirements: *id004
 - !ruby/object:Gem::Dependency 
@@ -193,5 +195,21 @@ rubygems_version: 1.3.6
 signing_key: 
 specification_version: 2
 summary: Generic interface to multiple Ruby template engines
-test_files: []
-
+test_files: 
+- test/tilt_buildertemplate_test.rb
+- test/tilt_cache_test.rb
+- test/tilt_coffeetemplate_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_mustachetemplate_test.rb
+- test/tilt_rdiscounttemplate_test.rb
+- test/tilt_rdoctemplate_test.rb
+- test/tilt_redclothtemplate_test.rb
+- test/tilt_sasstemplate_test.rb
+- test/tilt_stringtemplate_test.rb
+- test/tilt_template_test.rb
+- test/tilt_test.rb