tilt 1.4.1 → 2.0.11

data/lib/tilt/haml.rb

@@ -1,4 +1,5 @@
 require 'tilt/template'
+require 'haml'
 
 module Tilt
   # Haml template implementation. See:
@@ -6,59 +7,80 @@ 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)
-    end
+    # `Gem::Version.correct?` may return false because of Haml::VERSION #=> "3.1.8 (Separated Sally)". After Haml 4, it's always correct.
+    if Gem::Version.correct?(Haml::VERSION) && Gem::Version.new(Haml::VERSION) >= Gem::Version.new('5.0.0.beta.2')
+      def prepare
+        options = {}.update(@options).update(filename: eval_file, line: line)
+        if options.include?(:outvar)
+          options[:buffer] = options.delete(:outvar)
+          options[:save_buffer] = true
+        end
+        @engine = ::Haml::TempleEngine.new(options)
+        @engine.compile(data)
+      end
 
-    def evaluate(scope, locals, &block)
-      if @engine.respond_to?(:precompiled_method_return_value, true)
+      def evaluate(scope, locals, &block)
+        raise ArgumentError, 'invalid scope: must not be frozen' if scope.frozen?
         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 precompiled_template(locals)
-      @engine.precompiled
-    end
-
-    def precompiled_preamble(locals)
-      local_assigns = super
-      @engine.instance_eval do
-        <<-RUBY
-          begin
-            extend Haml::Helpers
-            _hamlout = @haml_buffer = Haml::Buffer.new(@haml_buffer, #{options_for_buffer.inspect})
-            _erbout = _hamlout.buffer
+      def precompiled_template(locals)
+        @engine.precompiled_with_ambles(
+          [],
+          after_preamble: <<-RUBY
             __in_erb_template = true
             _haml_locals = locals
-            #{local_assigns}
-        RUBY
+          RUBY
+        )
       end
-    end
+    else # Following definitions are for Haml <= 4 and deprecated.
+      def prepare
+        options = @options.merge(:filename => eval_file, :line => line)
+        @engine = ::Haml::Engine.new(data, options)
+      end
+
+      def evaluate(scope, locals, &block)
+        raise ArgumentError, 'invalid scope: must not be frozen' if scope.frozen?
 
-    def precompiled_postamble(locals)
-      @engine.instance_eval do
-        <<-RUBY
-            #{precompiled_method_return_value}
-          ensure
-            @haml_buffer = @haml_buffer.upper
-          end
-        RUBY
+        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 precompiled_template(locals)
+        @engine.precompiled
+      end
+
+      def precompiled_preamble(locals)
+        local_assigns = super
+        @engine.instance_eval do
+          <<-RUBY
+            begin
+              extend Haml::Helpers
+              _hamlout = @haml_buffer = Haml::Buffer.new(haml_buffer, #{options_for_buffer.inspect})
+              _erbout = _hamlout.buffer
+              __in_erb_template = true
+              _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 if haml_buffer
+            end
+          RUBY
+        end
       end
     end
   end
 end
-

data/lib/tilt/kramdown.rb

@@ -0,0 +1,25 @@
+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 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,30 @@
+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 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,8 +1,9 @@
 require 'tilt/template'
+require 'liquid'
 
 module Tilt
   # Liquid template implementation. See:
-  # http://liquid.rubyforge.org/
+  # http://liquidmarkup.org/
   #
   # Liquid is designed to be a *safe* template system and threfore
   # does not provide direct access to execuatable scopes. In order to
@@ -15,16 +16,8 @@ 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)
+      @engine = ::Liquid::Template.parse(data, liquid_options)
     end
 
     def evaluate(scope, locals, &block)
@@ -41,5 +34,11 @@ module Tilt
     def allows_script?
       false
     end
+
+    private
+
+    def liquid_options
+      { line_numbers: true }.merge options
+    end
   end
 end

data/lib/tilt/livescript.rb

@@ -0,0 +1,23 @@
+require 'tilt/template'
+require 'livescript'
+
+module Tilt
+  # LiveScript template implementation. See:
+  # http://livescript.net/
+  #
+  # LiveScript templates do not support object scopes, locals, or yield.
+  class LiveScriptTemplate < Template
+    self.default_mime_type = 'application/javascript'
+
+    def prepare
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= LiveScript.compile(data, options)
+    end
+
+    def allows_script?
+      false
+    end
+  end
+end

data/lib/tilt/mapping.rb

@@ -0,0 +1,293 @@
+require 'monitor'
+
+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
+
+    # Registers 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 attempted 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)
+      if template_class.respond_to?(:to_str)
+        # Support register(ext, template_class) too
+        extensions, template_class = [template_class], extensions[0]
+      end
+
+      extensions.each do |ext|
+        @template_map[ext.to_s] = 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)
+      _, 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
+
+    # Finds the extensions the template class has been registered under.
+    # @param [template class] template_class
+    def extensions_for(template_class)
+      res = []
+      template_map.each do |ext, klass|
+        res << ext if template_class == klass
+      end
+      lazy_map.each do |ext, choices|
+        res << ext if choices.any? { |klass, file| template_class.to_s == klass }
+      end
+      res
+    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
+
+    LOCK = Monitor.new
+
+    def lazy_load(pattern)
+      return unless @lazy_map.has_key?(pattern)
+
+      LOCK.enter
+      entered = true
+
+      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
+          # 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
+    ensure
+      LOCK.exit if entered
+    end
+
+    # This is due to a bug in JRuby (see GH issue jruby/jruby#3585)
+    Tilt.autoload :Dummy, "tilt/dummy"
+    require "tilt/dummy"
+    AUTOLOAD_IS_BROKEN = Tilt.autoload?(:Dummy)
+
+    # The proper behavior (in MRI) for autoload? is to
+    # return `false` when the constant/file has been
+    # explicitly required.
+    #
+    # However, in JRuby it returns `true` even after it's
+    # been required. In that case it turns out that `defined?`
+    # returns `"constant"` if it exists and `nil` when it doesn't.
+    # This is actually a second bug: `defined?` should resolve
+    # autoload (aka. actually try to require the file).
+    #
+    # We use the second bug in order to resolve the first bug.
+
+    def constant_defined?(name)
+      name.split('::').inject(Object) do |scope, n|
+        if scope.autoload?(n)
+          if !AUTOLOAD_IS_BROKEN
+            return false
+          end
+
+          if eval("!defined?(scope::#{n})")
+            return false
+          end
+        end
+        return false if !scope.const_defined?(n)
+        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/pandoc.rb

@@ -0,0 +1,57 @@
+require 'tilt/template'
+require 'pandoc-ruby'
+
+module Tilt
+  # Pandoc markdown implementation. See:
+  # http://pandoc.org/
+  class PandocTemplate < Template
+    self.default_mime_type = 'text/html'
+
+    # turn options hash into an array
+    # Map tilt options to pandoc options
+    # Replace hash keys with value true with symbol for key
+    # Remove hash keys with value false
+    # Leave other hash keys untouched
+    def pandoc_options
+      result = []
+      from = "markdown"
+      smart_extension = "-smart"
+      options.each do |k,v|
+        case k
+        when :smartypants
+          smart_extension = "+smart" if v
+        when :escape_html
+          from = "markdown-raw_html" if v
+        when :commonmark
+          from = "commonmark" if v
+        when :markdown_strict
+          from = "markdown_strict" if v
+        else
+          case v
+          when true
+            result << k
+          when false
+            # do nothing
+          else
+            result << { k => v }
+          end
+        end
+      end
+      result << { :f => from + smart_extension }
+      result
+    end
+
+    def prepare
+      @engine = PandocRuby.new(data, *pandoc_options)
+      @output = nil
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= @engine.to_html.strip
+    end
+
+    def allows_script?
+      false
+    end
+  end
+end

data/lib/tilt/plain.rb

@@ -6,10 +6,6 @@ module Tilt
   class PlainTemplate < Template
     self.default_mime_type = 'text/html'
 
-    def self.engine_initialized?
-      true
-    end
-
     def prepare
     end