tilt 1.4.0 → 2.0.0.beta1

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

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
+