tilt 1.3.3 → 1.3.4

data/lib/tilt/erb.rb

@@ -24,7 +24,7 @@ module Tilt
 
     def prepare
       @outvar = options[:outvar] || self.class.default_output_variable
-      options[:trim] = '<>' if options[:trim].nil? || options[:trim] == true
+      options[:trim] = '<>' if !(options[:trim] == false) && (options[:trim].nil? || options[:trim] == true)
       @engine = ::ERB.new(data, options[:safe], options[:trim], @outvar)
     end
 

data/lib/tilt/etanni.rb

@@ -0,0 +1,27 @@
+require 'tilt/template'
+
+module Tilt
+  class EtanniTemplate < Template
+    def prepare
+      separator = data.hash.abs
+      chomp = "<<#{separator}.chomp!"
+      start = "\n_out_ << #{chomp}\n"
+      stop = "\n#{separator}\n"
+      replacement = "#{stop}\\1#{start}"
+
+      temp = data.strip
+      temp.gsub!(/<\?r\s+(.*?)\s+\?>/m, replacement)
+
+      @code = "_out_ = [<<#{separator}.chomp!]\n#{temp}#{stop}_out_.join"
+    end
+
+    def precompiled_template(locals)
+      @code
+    end
+
+    def precompiled(locals)
+      source, offset = super
+      [source, offset + 1]
+    end
+  end
+end

data/lib/tilt/liquid.rb

@@ -37,5 +37,9 @@ module Tilt
       locals['content'] = locals['yield']
       @engine.render(locals)
     end
+
+    def allows_script?
+      false
+    end
   end
 end

data/lib/tilt/markdown.rb

@@ -37,6 +37,10 @@ module Tilt
     def evaluate(scope, locals, &block)
       @output ||= @engine.to_html
     end
+
+    def allows_script?
+      false
+    end
   end
 
   # Upskirt Markdown implementation. See:
@@ -53,7 +57,7 @@ module Tilt
     end
 
     def prepare
-      klass = [Redcarpet1, Redcarpet2].detect { |e| e.engine_initialized? }
+      klass = [Redcarpet2, Redcarpet1].detect { |e| e.engine_initialized? }
       @engine = klass.new(file, line, options) { data }
     end
 
@@ -61,6 +65,10 @@ module Tilt
       @engine.evaluate(scope, locals, &block)
     end
 
+    def allows_script?
+      false
+    end
+
     # Compatibility mode for Redcarpet 1.x
     class Redcarpet1 < RDiscountTemplate
       self.default_mime_type = 'text/html'
@@ -80,22 +88,22 @@ module Tilt
       self.default_mime_type = 'text/html'
 
       def self.engine_initialized?
-        defined? ::Redcarpet::Render
+        defined? ::Redcarpet::Render and defined? ::Redcarpet::Markdown
       end
 
       def generate_renderer
-        renderer = options.delete(:renderer) || Redcarpet::Render::HTML
+        renderer = options.delete(:renderer) || ::Redcarpet::Render::HTML
         return renderer unless options.delete(:smartypants)
-        return renderer if renderer <= Redcarpet::Render::SmartyPants
+        return renderer if renderer.is_a?(Class) && renderer <= ::Redcarpet::Render::SmartyPants
 
-        if renderer == Redcarpet::Render::XHTML
-          Redcarpet::Render::SmartyHTML.new(:xhtml => true)
-        elsif renderer == Redcarpet::Render::HTML
-          Redcarpet::Render::SmartyHTML
+        if renderer == ::Redcarpet::Render::XHTML
+          ::Redcarpet::Render::SmartyHTML.new(:xhtml => true)
+        elsif renderer == ::Redcarpet::Render::HTML
+          ::Redcarpet::Render::SmartyHTML
         elsif renderer.is_a? Class
-          Class.new(renderer) { include Redcarpet::Render::SmartyPants }
+          Class.new(renderer) { include ::Redcarpet::Render::SmartyPants }
         else
-          renderer.extend Redcarpet::Render::SmartyPants
+          renderer.extend ::Redcarpet::Render::SmartyPants
         end
       end
 
@@ -109,13 +117,17 @@ module Tilt
         # only raise an exception if someone is trying to enable :escape_html
         options.delete(:escape_html) unless options[:escape_html]
 
-        @engine = Redcarpet::Markdown.new(generate_renderer, options)
+        @engine = ::Redcarpet::Markdown.new(generate_renderer, options)
         @output = nil
       end
 
       def evaluate(scope, locals, &block)
         @output ||= @engine.render(data)
       end
+
+      def allows_script?
+        false
+      end
     end
   end
 
@@ -140,6 +152,10 @@ module Tilt
     def evaluate(scope, locals, &block)
       @output ||= @engine.to_html
     end
+
+    def allows_script?
+      false
+    end
   end
 
   # Maruku markdown implementation. See:
@@ -161,6 +177,10 @@ module Tilt
     def evaluate(scope, locals, &block)
       @output ||= @engine.to_html
     end
+
+    def allows_script?
+      false
+    end
   end
 
   # Kramdown Markdown implementation. See:
@@ -185,6 +205,10 @@ module Tilt
     def evaluate(scope, locals, &block)
       @output ||= @engine.to_html
     end
+
+    def allows_script?
+      false
+    end
   end
 end
 

data/lib/tilt/nokogiri.rb

@@ -4,6 +4,7 @@ module Tilt
   # Nokogiri template implementation. See:
   # http://nokogiri.org/
   class NokogiriTemplate < Template
+    DOCUMENT_HEADER = /^<\?xml version=\"1\.0\"\?>\n?/
     self.default_mime_type = 'text/xml'
 
     def self.engine_initialized?
@@ -16,11 +17,10 @@ module Tilt
 
     def prepare; end
 
-    def evaluate(scope, locals, &block)
-      block &&= proc { yield.gsub(/^<\?xml version=\"1\.0\"\?>\n?/, "") }
-
+    def evaluate(scope, locals)
       if data.respond_to?(:to_str)
-        super(scope, locals, &block)
+        wrapper = proc { yield.sub(DOCUMENT_HEADER, "") } if block_given?
+        super(scope, locals, &wrapper)
       else
         ::Nokogiri::XML::Builder.new.tap(&data).to_xml
       end

data/lib/tilt/plain.rb

@@ -0,0 +1,20 @@
+require 'tilt/template'
+
+
+module Tilt
+  # Raw text (no template functionality).
+  class PlainTemplate < Template
+    self.default_mime_type = 'text/html'
+
+    def self.engine_initialized?
+      true
+    end
+
+    def prepare
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= data
+    end
+  end
+end

data/lib/tilt/radius.rb

@@ -47,5 +47,9 @@ module Tilt
       parser = Radius::Parser.new(context, options)
       parser.parse(data)
     end
+
+    def allows_script?
+      false
+    end
   end
 end

data/lib/tilt/rdoc.rb

@@ -4,23 +4,34 @@ module Tilt
   # RDoc template. See:
   # http://rdoc.rubyforge.org/
   #
-  # It's suggested that your program require 'rdoc/markup' and
-  # 'rdoc/markup/to_html' at load time when using this template
-  # engine.
+  # It's suggested that your program `require 'rdoc/markup'` and
+  # `require 'rdoc/markup/to_html'` at load time when using this template
+  # engine in a threaded environment.
   class RDocTemplate < Template
     self.default_mime_type = 'text/html'
 
     def self.engine_initialized?
-      defined? ::RDoc::Markup
+      defined? ::RDoc::Markup::ToHtml
     end
 
     def initialize_engine
+      require_template_library 'rdoc'
       require_template_library 'rdoc/markup'
       require_template_library 'rdoc/markup/to_html'
     end
 
+    def markup
+      begin
+        # RDoc 4.0
+        require 'rdoc/options'
+        RDoc::Markup::ToHtml.new(RDoc::Options.new, nil)
+      rescue ArgumentError
+        # RDoc < 4.0
+        RDoc::Markup::ToHtml.new
+      end
+    end
+
     def prepare
-      markup = RDoc::Markup::ToHtml.new
       @engine = markup.convert(data)
       @output = nil
     end
@@ -28,5 +39,9 @@ module Tilt
     def evaluate(scope, locals, &block)
       @output ||= @engine.to_s
     end
+
+    def allows_script?
+      false
+    end
   end
 end

data/lib/tilt/template.rb

@@ -41,6 +41,7 @@ module Tilt
       [options, line, file].compact.each do |arg|
         case
         when arg.respond_to?(:to_str)  ; @file = arg.to_str
+        when arg.respond_to?(:path)    ; @file = arg.path
         when arg.respond_to?(:to_int)  ; @line = arg.to_int
         when arg.respond_to?(:to_hash) ; @options = arg.to_hash.dup
         else raise TypeError
@@ -91,6 +92,15 @@ module Tilt
       file || '(__TEMPLATE__)'
     end
 
+    # Whether or not this template engine allows executing Ruby script
+    # within the template. If this is false, +scope+ and +locals+ will
+    # generally not be used, nor will the provided block be avaiable 
+    # via +yield+.
+    # This should be overridden by template subclasses.
+    def allows_script?
+      true
+    end
+
   protected
     # Called once and only once for each template subclass the first time
     # the template class is initialized. This should be used to require the
@@ -98,7 +108,7 @@ module Tilt
     def initialize_engine
     end
 
-    # Like Kernel::require but issues a warning urging a manual require when
+    # 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
@@ -123,25 +133,15 @@ module Tilt
       end
     end
 
+    # Execute the compiled template and return the result string. Template
+    # evaluation is guaranteed to be performed in the scope object with the
+    # locals specified and with support for yielding to the block.
+    #
+    # This method is only used by source generating templates. Subclasses that
+    # override render() may not support all features.
     def evaluate(scope, locals, &block)
-      cached_evaluate(scope, locals, &block)
-    end
-
-    # 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 cached_evaluate(scope, locals, &block)
-      # Redefine itself to use method compilation the next time:
-      def self.cached_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)
+      method = compiled_method(locals.keys)
+      method.bind(scope).call(locals, &block)
     end
 
     # Generates all template source by combining the preamble, template, and
@@ -186,7 +186,13 @@ module Tilt
     # 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.inspect}]" }.join("\n")
+      locals.map do |k,v|
+        if k.to_s =~ /\A[a-z]\w*\z/
+          "#{k} = locals[#{k.inspect}]"
+        else
+          raise "invalid locals key: #{k.inspect} (keys must be variable names)"
+        end
+      end.join("\n")
     end
 
     # Generates postamble code for the precompiled template source. The
@@ -203,34 +209,10 @@ module Tilt
     end
 
   private
-    # 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
-
-    # 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
-    #
-    # We redefine evaluate_source to work around this 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)
-        scope.instance_eval { Kernel::eval(source, binding, file, lineno) }
-      end
-    end
-
     def compile_template_method(locals)
       source, offset = precompiled(locals)
-      offset += 5
       method_name = "__tilt_#{Thread.current.object_id.abs}"
-      Object.class_eval <<-RUBY, eval_file, line - offset
+      method_source = <<-RUBY
         #{extract_magic_comment source}
         TOPOBJECT.class_eval do
           def #{method_name}(locals)
@@ -238,12 +220,11 @@ module Tilt
             class << self
               this, locals = Thread.current[:tilt_vars]
               this.instance_eval do
-               #{source}
-              end
-            end
-          end
-        end
       RUBY
+      offset += method_source.count("\n")
+      method_source << source
+      method_source << "\nend;end;end;end"
+      Object.class_eval method_source, eval_file, line - offset
       unbind_compiled_method(method_name)
     end
 
@@ -255,30 +236,10 @@ module Tilt
 
     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.
-    #
-    # http://github.com/rtomayko/tilt/commit/20c01a5
-    # http://redmine.ruby-lang.org/issues/show/3601
-    #
-    # 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(locals)
-        source, offset = precompiled(locals)
-        offset += 1
-        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
-        unbind_compiled_method(method_name)
+      if comment && !%w[ascii-8bit binary].include?($1.downcase)
+        comment
+      elsif @default_encoding
+        "# coding: #{@default_encoding}"
       end
     end
   end

data/lib/tilt/textile.rb

@@ -14,12 +14,17 @@ module Tilt
 
     def prepare
       @engine = RedCloth.new(data)
+      options.each {|k, v| @engine.send("#{k}=", v) if @engine.respond_to? "#{k}="}
       @output = nil
     end
 
     def evaluate(scope, locals, &block)
       @output ||= @engine.to_html
     end
+
+    def allows_script?
+      false
+    end
   end
 end