tilt 1.4.1 → 2.0.0.beta1

data/lib/tilt/asciidoc.rb

@@ -1,4 +1,5 @@
 require 'tilt/template'
+require 'asciidoctor'
 
 # AsciiDoc see: http://asciidoc.org/
 module Tilt
@@ -11,14 +12,6 @@ module Tilt
   class AsciidoctorTemplate < Template
     self.default_mime_type = 'text/html'
 
-    def self.engine_initialized?
-      defined? ::Asciidoctor::Document
-    end
-
-    def initialize_engine
-      require_template_library 'asciidoctor'
-    end
-
     def prepare
       options[:header_footer] = false if options[:header_footer].nil?
     end

data/lib/tilt/bluecloth.rb

@@ -0,0 +1,24 @@
+require 'tilt/template'
+require 'bluecloth'
+
+module Tilt
+  # BlueCloth Markdown implementation. See:
+  # http://deveiate.org/projects/BlueCloth/
+  class BlueClothTemplate < Template
+    self.default_mime_type = 'text/html'
+
+    def prepare
+      @engine = BlueCloth.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/builder.rb

@@ -1,4 +1,5 @@
 require 'tilt/template'
+require 'builder'
 
 module Tilt
    # Builder template implementation. See:
@@ -6,14 +7,6 @@ module Tilt
   class BuilderTemplate < Template
     self.default_mime_type = 'text/xml'
 
-    def self.engine_initialized?
-      defined? ::Builder
-    end
-
-    def initialize_engine
-      require_template_library 'builder'
-    end
-
     def prepare; end
 
     def evaluate(scope, locals, &block)

data/lib/tilt/coffee.rb

@@ -1,4 +1,5 @@
 require 'tilt/template'
+require 'coffee_script'
 
 module Tilt
   # CoffeeScript template implementation. See:
@@ -28,14 +29,6 @@ module Tilt
       @@default_bare = value
     end
 
-    def self.engine_initialized?
-      defined? ::CoffeeScript
-    end
-
-    def initialize_engine
-      require_template_library 'coffee_script'
-    end
-
     def prepare
       if !options.key?(:bare) and !options.key?(:no_wrap)
         options[:bare] = self.class.default_bare

data/lib/tilt/creole.rb

@@ -0,0 +1,25 @@
+require 'tilt/template'
+require 'creole'
+
+module Tilt
+  # Creole implementation. See:
+  # http://www.wikicreole.org/
+  class CreoleTemplate < Template
+    def prepare
+      opts = {}
+      [:allowed_schemes, :extensions, :no_escape].each do |k|
+        opts[k] = options[k] if options[k]
+      end
+      @engine = Creole::Parser.new(data, opts)
+      @output = nil
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= @engine.to_html
+    end
+
+    def allows_script?
+      false
+    end
+  end
+end

data/lib/tilt/csv.rb

@@ -1,5 +1,11 @@
 require 'tilt/template'
 
+if RUBY_VERSION >= '1.9.0'
+  require 'csv'
+else
+  require 'fastercsv'
+end
+
 module Tilt
 
   # CSV Template implementation. See:
@@ -30,10 +36,6 @@ module Tilt
   class CSVTemplate < Template
     self.default_mime_type = 'text/csv'
 
-    def self.engine_initialized?
-      engine
-    end
-
     def self.engine
       if RUBY_VERSION >= '1.9.0' && defined? ::CSV
         ::CSV
@@ -42,14 +44,6 @@ module Tilt
       end
     end
 
-    def initialize_engine
-      if RUBY_VERSION >= '1.9.0'
-        require_template_library 'csv'
-      else
-        require_template_library 'fastercsv'
-      end
-    end
-
     def prepare
       @code =<<-RUBY
         #{self.class.engine}.generate do |csv|
@@ -68,4 +62,4 @@ module Tilt
     end
 
   end
-end
+end

data/lib/tilt/erb.rb

@@ -1,4 +1,5 @@
 require 'tilt/template'
+require 'erb'
 
 module Tilt
   # ERB template implementation. See:
@@ -11,17 +12,10 @@ module Tilt
     end
 
     def self.default_output_variable=(name)
+      warn "#{self}.default_output_variable= has been replaced with the :outvar-option"
       @@default_output_variable = name
     end
 
-    def self.engine_initialized?
-      defined? ::ERB
-    end
-
-    def initialize_engine
-      require_template_library 'erb'
-    end
-
     def prepare
       @outvar = options[:outvar] || self.class.default_output_variable
       options[:trim] = '<>' if !(options[:trim] == false) && (options[:trim].nil? || options[:trim] == true)
@@ -59,52 +53,5 @@ module Tilt
       end
     end
   end
-
-  # Erubis template implementation. See:
-  # http://www.kuwata-lab.com/erubis/
-  #
-  # ErubisTemplate supports the following additional options, which are not
-  # passed down to the Erubis engine:
-  #
-  #   :engine_class   allows you to specify a custom engine class to use
-  #                   instead of the default (which is ::Erubis::Eruby).
-  #
-  #   :escape_html    when true, ::Erubis::EscapedEruby will be used as
-  #                   the engine class instead of the default. All content
-  #                   within <%= %> blocks will be automatically html escaped.
-  class ErubisTemplate < ERBTemplate
-    def self.engine_initialized?
-      defined? ::Erubis::Eruby
-    end
-
-    def initialize_engine
-      require_template_library 'erubis'
-    end
-
-    def prepare
-      @outvar = options.delete(:outvar) || self.class.default_output_variable
-      @options.merge!(:preamble => false, :postamble => false, :bufvar => @outvar)
-      engine_class = options.delete(:engine_class)
-      engine_class = ::Erubis::EscapedEruby if options.delete(:escape_html)
-      @engine = (engine_class || ::Erubis::Eruby).new(data, options)
-    end
-
-    def precompiled_preamble(locals)
-      [super, "#{@outvar} = _buf = ''"].join("\n")
-    end
-
-    def precompiled_postamble(locals)
-      [@outvar, 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 precompiled(locals)
-        source, offset = super
-        [source, offset - 1]
-      end
-    end
-  end
 end
 

data/lib/tilt/erubis.rb

@@ -0,0 +1,43 @@
+require 'tilt/erb'
+require 'erubis'
+
+module Tilt
+  # Erubis template implementation. See:
+  # http://www.kuwata-lab.com/erubis/
+  #
+  # ErubisTemplate supports the following additional options, which are not
+  # passed down to the Erubis engine:
+  #
+  #   :engine_class   allows you to specify a custom engine class to use
+  #                   instead of the default (which is ::Erubis::Eruby).
+  #
+  #   :escape_html    when true, ::Erubis::EscapedEruby will be used as
+  #                   the engine class instead of the default. All content
+  #                   within <%= %> blocks will be automatically html escaped.
+  class ErubisTemplate < ERBTemplate
+    def prepare
+      @outvar = options.delete(:outvar) || self.class.default_output_variable
+      @options.merge!(:preamble => false, :postamble => false, :bufvar => @outvar)
+      engine_class = options.delete(:engine_class)
+      engine_class = ::Erubis::EscapedEruby if options.delete(:escape_html)
+      @engine = (engine_class || ::Erubis::Eruby).new(data, options)
+    end
+
+    def precompiled_preamble(locals)
+      [super, "#{@outvar} = _buf = ''"].join("\n")
+    end
+
+    def precompiled_postamble(locals)
+      [@outvar, 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 precompiled(locals)
+        source, offset = super
+        [source, offset - 1]
+      end
+    end
+  end
+end

data/lib/tilt/haml.rb

@@ -1,4 +1,5 @@
 require 'tilt/template'
+require 'haml'
 
 module Tilt
   # Haml template implementation. See:
@@ -6,14 +7,6 @@ module Tilt
   class HamlTemplate < Template
     self.default_mime_type = 'text/html'
 
-    def self.engine_initialized?
-      defined? ::Haml::Engine
-    end
-
-    def initialize_engine
-      require_template_library 'haml'
-    end
-
     def prepare
       options = @options.merge(:filename => eval_file, :line => line)
       @engine = ::Haml::Engine.new(data, options)

data/lib/tilt/kramdown.rb

@@ -0,0 +1,33 @@
+require 'tilt/template'
+require 'kramdown'
+
+module Tilt
+  # Kramdown Markdown implementation. See:
+  # http://kramdown.rubyforge.org/
+  class KramdownTemplate < Template
+    DUMB_QUOTES = [39, 39, 34, 34]
+
+    def self.engine_initialized?
+      defined? ::Kramdown
+    end
+
+    def initialize_engine
+      require_template_library 'kramdown'
+    end
+
+    def prepare
+      options[:smart_quotes] = DUMB_QUOTES unless options[:smartypants]
+      @engine = Kramdown::Document.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/less.rb

@@ -0,0 +1,38 @@
+require 'tilt/template'
+require 'less'
+
+module Tilt
+  # Lessscss template implementation. See:
+  # http://lesscss.org/
+  #
+  # Less templates do not support object scopes, locals, or yield.
+  class LessTemplate < Template
+    self.default_mime_type = 'text/css'
+
+    def self.engine_initialized?
+      defined? ::Less
+    end
+
+    def initialize_engine
+      require_template_library 'less'
+    end
+
+    def prepare
+      if ::Less.const_defined? :Engine
+        @engine = ::Less::Engine.new(data)
+      else
+        parser  = ::Less::Parser.new(options.merge :filename => eval_file, :line => line)
+        @engine = parser.parse(data)
+      end
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= @engine.to_css(options)
+    end
+
+    def allows_script?
+      false
+    end
+  end
+end
+

data/lib/tilt/liquid.rb

@@ -1,4 +1,5 @@
 require 'tilt/template'
+require 'liquid'
 
 module Tilt
   # Liquid template implementation. See:
@@ -15,14 +16,6 @@ module Tilt
   # It's suggested that your program require 'liquid' at load
   # time when using this template engine.
   class LiquidTemplate < Template
-    def self.engine_initialized?
-      defined? ::Liquid::Template
-    end
-
-    def initialize_engine
-      require_template_library 'liquid'
-    end
-
     def prepare
       @engine = ::Liquid::Template.parse(data)
     end

data/lib/tilt/mapping.rb

@@ -0,0 +1,247 @@
+module Tilt
+  # Tilt::Mapping associates file extensions with template implementations.
+  #
+  #     mapping = Tilt::Mapping.new
+  #     mapping.register(Tilt::RDocTemplate, 'rdoc')
+  #     mapping['index.rdoc'] # => Tilt::RDocTemplate
+  #     mapping.new('index.rdoc').render
+  #
+  # You can use {#register} to register a template class by file
+  # extension, {#registered?} to see if a file extension is mapped,
+  # {#[]} to lookup template classes, and {#new} to instantiate template
+  # objects.
+  #
+  # Mapping also supports *lazy* template implementations. Note that regularly
+  # registered template implementations *always* have preference over lazily
+  # registered template implementations. You should use {#register} if you
+  # depend on a specific template implementation and {#register_lazy} if there
+  # are multiple alternatives.
+  #
+  #     mapping = Tilt::Mapping.new
+  #     mapping.register_lazy('RDiscount::Template', 'rdiscount/template', 'md')
+  #     mapping['index.md']
+  #     # => RDiscount::Template
+  #
+  # {#register_lazy} takes a class name, a filename, and a list of file
+  # extensions. When you try to lookup a template name that matches the
+  # file extension, Tilt will automatically try to require the filename and
+  # constantize the class name.
+  #
+  # Unlike {#register}, there can be multiple template implementations
+  # registered lazily to the same file extension. Tilt will attempt to load the
+  # template implementations in order (registered *last* would be tried first),
+  # returning the first which doesn't raise LoadError.
+  #
+  # If all of the registered template implementations fails, Tilt will raise
+  # the exception of the first, since that was the most preferred one.
+  #
+  #     mapping = Tilt::Mapping.new
+  #     mapping.register_lazy('Bluecloth::Template', 'bluecloth/template', 'md')
+  #     mapping.register_lazy('RDiscount::Template', 'rdiscount/template', 'md')
+  #     mapping['index.md']
+  #     # => RDiscount::Template
+  #
+  # In the previous example we say that RDiscount has a *higher priority* than
+  # BlueCloth. Tilt will first try to `require "rdiscount/template"`, falling
+  # back to `require "bluecloth/template"`. If none of these are successful,
+  # the first error will be raised.
+  class Mapping
+    # @private
+    attr_reader :lazy_map, :template_map
+
+    def initialize
+      @template_map = Hash.new
+      @lazy_map = Hash.new { |h, k| h[k] = [] }
+    end
+
+    # @private
+    def initialize_copy(other)
+      @template_map = other.template_map.dup
+      @lazy_map = other.lazy_map.dup
+    end
+
+    # Registrers a lazy template implementation by file extension. You
+    # can have multiple lazy template implementations defined on the
+    # same file extension, in which case the template implementation
+    # defined *last* will be attemted loaded *first*.
+    #
+    # @param class_name [String] Class name of a template class.
+    # @param file [String] Filename where the template class is defined.
+    # @param extensions [Array<String>] List of extensions.
+    # @return [void]
+    #
+    # @example
+    #   mapping.register_lazy 'MyEngine::Template', 'my_engine/template',  'mt'
+    #
+    #   defined?(MyEngine::Template) # => false
+    #   mapping['index.mt'] # => MyEngine::Template
+    #   defined?(MyEngine::Template) # => true
+    def register_lazy(class_name, file, *extensions)
+      # Internal API
+      if class_name.is_a?(Symbol)
+        Tilt.autoload class_name, file
+        class_name = "Tilt::#{class_name}"
+      end
+
+      extensions.each do |ext|
+        @lazy_map[ext].unshift([class_name, file])
+      end
+    end
+
+    # Registers a template implementation by file extension. There can only be
+    # one template implementation per file extension, and this method will
+    # override any existing mapping.
+    #
+    # @param template_class
+    # @param extensions [Array<String>] List of extensions.
+    # @return [void]
+    # 
+    # @example
+    #   mapping.register MyEngine::Template, 'mt'
+    #   mapping['index.mt'] # => MyEngine::Template
+    def register(template_class, *extensions)
+      extensions.each do |ext|
+        @template_map[ext] = template_class
+      end
+    end
+
+    # Checks if a file extension is registered (either eagerly or
+    # lazily) in this mapping.
+    #
+    # @param ext [String] File extension.
+    #
+    # @example
+    #   mapping.registered?('erb')  # => true
+    #   mapping.registered?('nope') # => false
+    def registered?(ext)
+      @template_map.has_key?(ext.downcase) or lazy?(ext)
+    end
+
+    # Instantiates a new template class based on the file.
+    #
+    # @raise [RuntimeError] if there is no template class registered for the
+    #   file name.
+    #
+    # @example
+    #   mapping.new('index.mt') # => instance of MyEngine::Template
+    #
+    # @see Tilt::Template.new
+    def new(file, line=nil, options={}, &block)
+      if template_class = self[file]
+        template_class.new(file, line, options, &block)
+      else
+        fail "No template engine registered for #{File.basename(file)}"
+      end
+    end
+
+    # Looks up a template class based on file name and/or extension.
+    #
+    # @example
+    #   mapping['views/hello.erb'] # => Tilt::ERBTemplate
+    #   mapping['hello.erb']       # => Tilt::ERBTemplate
+    #   mapping['erb']             # => Tilt::ERBTemplate
+    #
+    # @return [template class]
+    def [](file)
+      prefix, ext = split(file)
+      ext && lookup(ext)
+    end
+
+    alias template_for []
+
+    # Looks up a list of template classes based on file name. If the file name
+    # has multiple extensions, it will return all template classes matching the
+    # extensions from the end.
+    #
+    # @example
+    #   mapping.templates_for('views/index.haml.erb')
+    #   # => [Tilt::ERBTemplate, Tilt::HamlTemplate]
+    #
+    # @return [Array<template class>]
+    def templates_for(file)
+      templates = []
+
+      while true
+        prefix, ext = split(file)
+        break unless ext
+        templates << lookup(ext)
+        file = prefix
+      end
+
+      templates
+    end
+
+    private
+
+    def lazy?(ext)
+      ext = ext.downcase
+      @lazy_map.has_key?(ext) && !@lazy_map[ext].empty?
+    end
+
+    def split(file)
+      pattern = file.to_s.downcase
+      full_pattern = pattern.dup
+
+      until registered?(pattern)
+        return if pattern.empty?
+        pattern = File.basename(pattern)
+        pattern.sub!(/^[^.]*\.?/, '')
+      end
+
+      prefix_size = full_pattern.size - pattern.size
+      [full_pattern[0,prefix_size-1], pattern]
+    end
+
+    def lookup(ext)
+      @template_map[ext] || lazy_load(ext)
+    end
+
+    def lazy_load(pattern)
+      return unless @lazy_map.has_key?(pattern)
+
+      choices = @lazy_map[pattern]
+
+      # Check if a template class is already present
+      choices.each do |class_name, file|
+        template_class = constant_defined?(class_name)
+        if template_class
+          register(template_class, pattern)
+          return template_class
+        end
+      end
+
+      first_failure = nil
+
+      # Load in order
+      choices.each do |class_name, file|
+        begin
+          require file
+
+          if Thread.list.size > 1
+            warn "WARN: tilt autoloading '#{file}' in a non thread-safe way; " +
+              "explicit require '#{file}' suggested."
+          end
+
+          # It's safe to eval() here because constant_defined? will
+          # raise NameError on invalid constant names
+          template_class = eval(class_name)
+        rescue LoadError => ex
+          first_failure ||= ex
+        else
+          register(template_class, pattern)
+          return template_class
+        end
+      end
+
+      raise first_failure if first_failure
+    end
+
+    def constant_defined?(name)
+      name.split('::').inject(Object) do |scope, n|
+        return false unless scope.const_defined?(n)
+        return false if scope.autoload?(n) # skip autload
+        scope.const_get(n)
+      end
+    end
+  end
+end