tilt 1.4.1 → 2.0.0.beta1

data/lib/tilt/markaby.rb

@@ -1,4 +1,5 @@
 require 'tilt/template'
+require 'markaby'
 
 module Tilt
   # Markaby
@@ -14,14 +15,6 @@ module Tilt
       end
     end
 
-    def self.engine_initialized?
-      defined? ::Markaby
-    end
-
-    def initialize_engine
-      require_template_library 'markaby'
-    end
-
     def prepare
     end
 

data/lib/tilt/maruku.rb

@@ -0,0 +1,22 @@
+require 'tilt/template'
+require 'maruku'
+
+module Tilt
+  # Maruku markdown implementation. See:
+  # http://maruku.rubyforge.org/
+  class MarukuTemplate < Template
+    def prepare
+      @engine = Maruku.new(data, options)
+      @output = nil
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= @engine.to_html
+    end
+
+    def allows_script?
+      false
+    end
+  end
+end
+

data/lib/tilt/nokogiri.rb

@@ -1,4 +1,5 @@
 require 'tilt/template'
+require 'nokogiri'
 
 module Tilt
   # Nokogiri template implementation. See:
@@ -7,14 +8,6 @@ module Tilt
     DOCUMENT_HEADER = /^<\?xml version=\"1\.0\"\?>\n?/
     self.default_mime_type = 'text/xml'
 
-    def self.engine_initialized?
-      defined? ::Nokogiri
-    end
-
-    def initialize_engine
-      require_template_library 'nokogiri'
-    end
-
     def prepare; end
 
     def evaluate(scope, locals)

data/lib/tilt/radius.rb

@@ -1,13 +1,10 @@
 require 'tilt/template'
+require 'radius'
 
 module Tilt
   # Radius Template
   # http://github.com/jlong/radius/
   class RadiusTemplate < Template
-    def self.engine_initialized?
-      defined? ::Radius
-    end
-
     def self.context_class
       @context_class ||= Class.new(Radius::Context) do
         attr_accessor :tilt_scope
@@ -24,10 +21,6 @@ module Tilt
       end
     end
 
-    def initialize_engine
-      require_template_library 'radius'
-    end
-
     def prepare
     end
 

data/lib/tilt/rdiscount.rb

@@ -0,0 +1,39 @@
+require 'tilt/template'
+require 'rdiscount'
+
+module Tilt
+  # Discount Markdown implementation. See:
+  # http://github.com/rtomayko/rdiscount
+  #
+  # RDiscount is a simple text filter. It does not support +scope+ or
+  # +locals+. The +:smart+ and +:filter_html+ options may be set true
+  # to enable those flags on the underlying RDiscount object.
+  class RDiscountTemplate < Template
+    self.default_mime_type = 'text/html'
+
+    ALIAS = {
+      :escape_html => :filter_html,
+      :smartypants => :smart
+    }
+
+    FLAGS = [:smart, :filter_html, :smartypants, :escape_html]
+
+    def flags
+      FLAGS.select { |flag| options[flag] }.map { |flag| ALIAS[flag] || flag }
+    end
+
+    def prepare
+      @engine = RDiscount.new(data, *flags)
+      @output = nil
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= @engine.to_html
+    end
+
+    def allows_script?
+      false
+    end
+  end
+end
+

data/lib/tilt/rdoc.rb

@@ -1,4 +1,7 @@
 require 'tilt/template'
+require 'rdoc'
+require 'rdoc/markup'
+require 'rdoc/markup/to_html'
 
 module Tilt
   # RDoc template. See:
@@ -10,16 +13,6 @@ module Tilt
   class RDocTemplate < Template
     self.default_mime_type = 'text/html'
 
-    def self.engine_initialized?
-      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

data/lib/tilt/redcarpet.rb

@@ -0,0 +1,104 @@
+require 'tilt/template'
+require 'redcarpet'
+
+module Tilt
+  # Compatibility mode for Redcarpet 1.x
+  class Redcarpet1Template < Template
+    self.default_mime_type = 'text/html'
+
+    ALIAS = {
+      :escape_html => :filter_html,
+      :smartypants => :smart
+    }
+
+    FLAGS = [:smart, :filter_html, :smartypants, :escape_html]
+
+    def flags
+      FLAGS.select { |flag| options[flag] }.map { |flag| ALIAS[flag] || flag }
+    end
+
+    def prepare
+      @engine = RedcarpetCompat.new(data, *flags)
+      @output = nil
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= @engine.to_html
+    end
+
+    def allows_script?
+      false
+    end
+  end
+
+  # Future proof mode for Redcarpet 2.x (not yet released)
+  class Redcarpet2Template < Template
+    self.default_mime_type = 'text/html'
+
+    def self.engine_initialized?
+      defined? ::Redcarpet::Render and defined? ::Redcarpet::Markdown
+    end
+
+    def generate_renderer
+      renderer = options.delete(:renderer) || ::Redcarpet::Render::HTML
+      return renderer unless options.delete(: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
+      elsif renderer.is_a? Class
+        Class.new(renderer) { include ::Redcarpet::Render::SmartyPants }
+      else
+        renderer.extend ::Redcarpet::Render::SmartyPants
+      end
+    end
+
+    def prepare
+      # try to support the same aliases
+      Redcarpet1Template::ALIAS.each do |opt, aka|
+        next if options.key? opt or not options.key? aka
+        options[opt] = options.delete(aka)
+      end
+
+      # 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)
+      @output = nil
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= @engine.render(data)
+    end
+
+    def allows_script?
+      false
+    end
+  end
+
+  # Upskirt Markdown implementation. See:
+  # https://github.com/tanoku/redcarpet
+  #
+  # Supports both Redcarpet 1.x and 2.x
+  class RedcarpetTemplate < Template
+    Redcarpet1 = Redcarpet1Template
+    Redcarpet2 = Redcarpet2Template
+
+    def prepare
+      klass = Redcarpet2.engine_initialized? ? Redcarpet2 : Redcarpet1
+      @engine = klass.new(file, line, options) { data }
+    end
+
+    def evaluate(scope, locals, &block)
+      @engine.evaluate(scope, locals, &block)
+    end
+
+    def allows_script?
+      false
+    end
+  end
+
+end
+

data/lib/tilt/{textile.rb → redcloth.rb}

@@ -1,17 +1,10 @@
 require 'tilt/template'
+require 'redcloth'
 
 module Tilt
   # RedCloth implementation. See:
   # http://redcloth.org/
   class RedClothTemplate < Template
-    def self.engine_initialized?
-      defined? ::RedCloth
-    end
-
-    def initialize_engine
-      require_template_library 'redcloth'
-    end
-
     def prepare
       @engine = RedCloth.new(data)
       options.each {|k, v| @engine.send("#{k}=", v) if @engine.respond_to? "#{k}="}

data/lib/tilt/sass.rb

@@ -0,0 +1,41 @@
+require 'tilt/template'
+require 'sass'
+
+module Tilt
+  # Sass template implementation. See:
+  # http://haml.hamptoncatlin.com/
+  #
+  # Sass templates do not support object scopes, locals, or yield.
+  class SassTemplate < Template
+    self.default_mime_type = 'text/css'
+
+    def prepare
+      @engine = ::Sass::Engine.new(data, sass_options)
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= @engine.render
+    end
+
+    def allows_script?
+      false
+    end
+
+  private
+    def sass_options
+      options.merge(:filename => eval_file, :line => line, :syntax => :sass)
+    end
+  end
+
+  # Sass's new .scss type template implementation.
+  class ScssTemplate < SassTemplate
+    self.default_mime_type = 'text/css'
+
+  private
+    def sass_options
+      options.merge(:filename => eval_file, :line => line, :syntax => :scss)
+    end
+  end
+
+end
+

data/lib/tilt/template.rb

@@ -1,5 +1,11 @@
+require 'tilt'
+require 'thread'
+
 module Tilt
+  # @private
   TOPOBJECT = Object.superclass || Object
+  # @private
+  LOCK = Mutex.new
 
   # Base class for template implementations. Subclasses must implement
   # the #prepare method and one of the #evaluate or #precompiled_template
@@ -19,14 +25,22 @@ module Tilt
     # interface.
     attr_reader :options
 
-    # Used to determine if this class's initialize_engine method has
-    # been called yet.
-    @engine_initialized = false
     class << self
-      attr_accessor :engine_initialized
-      alias engine_initialized? engine_initialized
+      # An empty Hash that the template engine can populate with various
+      # metadata.
+      def metadata
+        @metadata ||= {}
+      end
 
-      attr_accessor :default_mime_type
+      # @deprecated Use `.metadata[:mime_type]` instead.
+      def default_mime_type
+        metadata[:mime_type]
+      end
+
+      # @deprecated Use `.metadata[:mime_type] = val` instead.
+      def default_mime_type=(value)
+        metadata[:mime_type] = value
+      end
     end
 
     # Create a new template with the file, line, and options specified. By
@@ -50,13 +64,6 @@ module Tilt
 
       raise ArgumentError, "file or block required" if (@file || block).nil?
 
-      # call the initialize_engine method if this is the very first time
-      # an instance of this class has been created.
-      if !self.class.engine_initialized?
-        initialize_engine
-        self.class.engine_initialized = true
-      end
-
       # used to hold compiled template methods
       @compiled_method = {}
 
@@ -79,28 +86,15 @@ module Tilt
       prepare
     end
 
-    # The encoding of the source data. Defaults to the
-    # default_encoding-option if present. You may override this method
-    # in your template class if you have a better hint of the data's
-    # encoding.
-    def default_encoding
-      @default_encoding
-    end
-
-    def read_template_file
-      data = File.open(file, 'rb') { |io| io.read }
-      if data.respond_to?(:force_encoding)
-        # Set it to the default external (without verifying)
-        data.force_encoding(Encoding.default_external) if Encoding.default_external
-      end
-      data
-    end
-
     # Render the template in the given scope with the locals specified. If a
     # block is given, it is typically available within the template via
     # +yield+.
     def render(scope=Object.new, locals={}, &block)
-      evaluate scope, locals || {}, &block
+      current_template = Thread.current[:tilt_current_template]
+      Thread.current[:tilt_current_template] = self
+      evaluate(scope, locals || {}, &block)
+    ensure
+      Thread.current[:tilt_current_template] = current_template
     end
 
     # The basename of the template file.
@@ -118,30 +112,26 @@ 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
+    # An empty Hash that the template engine can populate with various
+    # metadata.
+    def metadata
+      if respond_to?(:allows_script?)
+        self.class.metadata.merge(:allows_script => allows_script?)
+      else
+        self.class.metadata
+      end
     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
-    # underlying template library and perform any initial setup.
-    def initialize_engine
-    end
+    protected
 
-    # 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
+    # @!group For template implementations
+
+    # The encoding of the source data. Defaults to the
+    # default_encoding-option if present. You may override this method
+    # in your template class if you have a better hint of the data's
+    # encoding.
+    def default_encoding
+      @default_encoding
     end
 
     # Do whatever preparation is necessary to setup the underlying template
@@ -150,13 +140,7 @@ module Tilt
     #
     # Subclasses must provide an implementation of this method.
     def prepare
-      if respond_to?(:compile!)
-        # backward compat with tilt < 0.6; just in case
-        warn 'Tilt::Template#compile! is deprecated; implement #prepare instead.'
-        compile!
-      else
-        raise NotImplementedError
-      end
+      raise NotImplementedError
     end
 
     # Execute the compiled template and return the result string. Template
@@ -179,10 +163,10 @@ module Tilt
     # 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)
-      template = precompiled_template(locals)
-      postamble = precompiled_postamble(locals)
+    def precompiled(local_keys)
+      preamble = precompiled_preamble(local_keys)
+      template = precompiled_template(local_keys)
+      postamble = precompiled_postamble(local_keys)
       source = ''
 
       # Ensure that our generated source code has the same encoding as the
@@ -194,10 +178,7 @@ module Tilt
         template.force_encoding(template_encoding)
       end
 
-      # https://github.com/rtomayko/tilt/issues/193
-      warn "precompiled_preamble should return String (not Array)" if preamble.is_a?(Array)
-      warn "precompiled_postamble should return String (not Array)" if postamble.is_a?(Array)
-      source << [preamble, template, postamble].join("\n")
+      source << preamble << "\n" << template << "\n" << postamble
 
       [source, preamble.count("\n")+1]
     end
@@ -208,41 +189,52 @@ module Tilt
     # the base Template guarantees correct file/line handling, locals
     # support, custom scopes, proper encoding, and support for template
     # compilation.
-    def precompiled_template(locals)
+    def precompiled_template(local_keys)
       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 do |k,v|
-        if k.to_s =~ /\A[a-z_][a-zA-Z_0-9]*\z/
-          "#{k} = locals[#{k.inspect}]"
-        else
-          raise "invalid locals key: #{k.inspect} (keys must be variable names)"
-        end
-      end.join("\n")
+    def precompiled_preamble(local_keys)
+      ''
     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)
+    def precompiled_postamble(local_keys)
       ''
     end
 
+    # !@endgroup
+
+    private
+
+    def read_template_file
+      data = File.open(file, 'rb') { |io| io.read }
+      if data.respond_to?(:force_encoding)
+        # Set it to the default external (without verifying)
+        data.force_encoding(Encoding.default_external) if Encoding.default_external
+      end
+      data
+    end
+
     # The compiled method for the locals keys provided.
     def compiled_method(locals_keys)
-      @compiled_method[locals_keys] ||=
-        compile_template_method(locals_keys)
+      LOCK.synchronize do
+        @compiled_method[locals_keys] ||= compile_template_method(locals_keys)
+      end
+    end
+
+    def local_extraction(local_keys)
+      local_keys.map do |k|
+        if k.to_s =~ /\A[a-z_][a-zA-Z_0-9]*\z/
+          "#{k} = locals[#{k.inspect}]"
+        else
+          raise "invalid locals key: #{k.inspect} (keys must be variable names)"
+        end
+      end.join("\n")
     end
 
-  private
-    def compile_template_method(locals)
-      source, offset = precompiled(locals)
+    def compile_template_method(local_keys)
+      source, offset = precompiled(local_keys)
+      local_code = local_extraction(local_keys)
+
       method_name = "__tilt_#{Thread.current.object_id.abs}"
       method_source = ""
 
@@ -257,11 +249,12 @@ module Tilt
             class << self
               this, locals = Thread.current[:tilt_vars]
               this.instance_eval do
+                #{local_code}
       RUBY
       offset += method_source.count("\n")
       method_source << source
       method_source << "\nend;end;end;end"
-      Object.class_eval method_source, eval_file, line - offset
+      Object.class_eval(method_source, eval_file, line - offset)
       unbind_compiled_method(method_name)
     end
 
@@ -276,7 +269,7 @@ module Tilt
     end
 
     def extract_magic_comment(script)
-      binary script do
+      binary(script) do
         script[/\A[ \t]*\#.*coding\s*[=:]\s*([[:alnum:]\-_]+).*$/n, 1]
       end
     end