tilt 2.0.0 → 2.4.0

data/lib/tilt/mapping.rb

@@ -1,4 +1,81 @@
+# frozen_string_literal: true
+require_relative 'pipeline'
+
 module Tilt
+  # Private internal base class for both Mapping and FinalizedMapping, for the shared methods.
+  class BaseMapping
+    # 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
+
+    private
+
+    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!(/\A[^.]*\.?/, '')
+      end
+
+      prefix_size = full_pattern.size - pattern.size
+      [full_pattern[0,prefix_size-1], pattern]
+    end
+  end
+  private_constant :BaseMapping
+
   # Tilt::Mapping associates file extensions with template implementations.
   #
   #     mapping = Tilt::Mapping.new
@@ -36,16 +113,18 @@ module Tilt
   # 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('Maruku::Template', 'maruku/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,
+  # Maruku. Tilt will first try to `require "rdiscount/template"`, falling
+  # back to `require "maruku/template"`. If none of these are successful,
   # the first error will be raised.
-  class Mapping
+  class Mapping < BaseMapping
+    LOCK = Mutex.new
+
     # @private
     attr_reader :lazy_map, :template_map
 
@@ -56,11 +135,29 @@ module Tilt
 
     # @private
     def initialize_copy(other)
-      @template_map = other.template_map.dup
-      @lazy_map = other.lazy_map.dup
+      LOCK.synchronize do
+        @template_map = other.template_map.dup
+        @lazy_map = other.lazy_map.dup
+      end
+    end
+
+    # Return a finalized mapping. A finalized mapping will only include
+    # support for template libraries already loaded, and will not
+    # allow registering new template libraries or lazy loading template
+    # libraries not yet loaded. Finalized mappings improve performance
+    # by not requiring synchronization and ensure that the mapping will
+    # not attempt to load additional files (useful when restricting
+    # file system access after template libraries in use are loaded).
+    def finalized
+      LOCK.synchronize{@lazy_map.dup}.each do |pattern, classes|
+        register_defined_classes(LOCK.synchronize{classes.map(&:first)}, pattern)
+      end
+
+      # Check if a template class is already present
+      FinalizedMapping.new(LOCK.synchronize{@template_map.dup}.freeze)
     end
 
-    # Registrers a lazy template implementation by file extension. You
+    # 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*.
@@ -83,8 +180,9 @@ module Tilt
         class_name = "Tilt::#{class_name}"
       end
 
+      v = [class_name, file].freeze
       extensions.each do |ext|
-        @lazy_map[ext].unshift([class_name, file])
+        LOCK.synchronize{@lazy_map[ext].unshift(v)}
       end
     end
 
@@ -106,86 +204,95 @@ module Tilt
       end
 
       extensions.each do |ext|
-        @template_map[ext.to_s] = template_class
+        ext = ext.to_s
+        LOCK.synchronize do
+          @template_map[ext] = template_class
+        end
       end
     end
 
-    # Checks if a file extension is registered (either eagerly or
-    # lazily) in this mapping.
+    # Register a new template class using the given extension that
+    # represents a pipeline of multiple existing template, where the
+    # output from the previous template is used as input to the next
+    # template.
     #
-    # @param ext [String] File extension.
+    # This will register a template class that processes the input
+    # with the *erb* template processor, and takes the output of
+    # that and feeds it to the *scss* template processor, returning
+    # the output of the *scss* template processor as the result of
+    # the pipeline.
+    #
+    # @param ext [String] Primary extension to register
+    # @option :templates [Array<String>] Extensions of templates
+    #         to execute in order (defaults to the ext.split('.').reverse)
+    # @option :extra_exts [Array<String>] Additional extensions to register
+    # @option String [Hash] Options hash for individual template in the
+    #         pipeline (key is extension).
+    # @return [void]
     #
     # @example
-    #   mapping.registered?('erb')  # => true
-    #   mapping.registered?('nope') # => false
-    def registered?(ext)
-      @template_map.has_key?(ext.downcase) or lazy?(ext)
+    #   mapping.register_pipeline('scss.erb')
+    #   mapping.register_pipeline('scss.erb', 'erb'=>{:outvar=>'@foo'})
+    #   mapping.register_pipeline('scsserb', :extra_exts => 'scss.erb',
+    #                             :templates=>['erb', 'scss'])
+    def register_pipeline(ext, options=EMPTY_HASH)
+      templates = options[:templates] || ext.split('.').reverse
+      templates = templates.map{|t| [self[t], options[t] || EMPTY_HASH]}
+
+      klass = Class.new(Pipeline)
+      klass.send(:const_set, :TEMPLATES, templates)
+
+      register(klass, ext, *Array(options[:extra_exts]))
+      klass
     end
 
-    # Instantiates a new template class based on the file.
+    # Unregisters an extension. This removes the both normal registrations
+    # and lazy registrations.
     #
-    # @raise [RuntimeError] if there is no template class registered for the
-    #   file name.
+    # @param extensions [Array<String>] List of extensions.
+    # @return nil
     #
     # @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)}"
+    #   mapping.register MyEngine::Template, 'mt'
+    #   mapping['index.mt'] # => MyEngine::Template
+    #   mapping.unregister('mt')
+    #   mapping['index.mt'] # => nil
+    def unregister(*extensions)
+      extensions.each do |ext|
+        ext = ext.to_s
+        LOCK.synchronize do
+          @template_map.delete(ext)
+          @lazy_map.delete(ext)
+        end
       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)
+      nil
     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.
+    # Checks if a file extension is registered (either eagerly or
+    # lazily) in this mapping.
     #
-    # @example
-    #   mapping.templates_for('views/index.haml.erb')
-    #   # => [Tilt::ERBTemplate, Tilt::HamlTemplate]
+    # @param ext [String] File extension.
     #
-    # @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
+    # @example
+    #   mapping.registered?('erb')  # => true
+    #   mapping.registered?('nope') # => false
+    def registered?(ext)
+      ext_downcase = ext.downcase
+      LOCK.synchronize{@template_map.has_key?(ext_downcase)} or lazy?(ext)
     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|
+      LOCK.synchronize{@template_map.to_a}.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 }
+      LOCK.synchronize{@lazy_map.to_a}.each do |ext, choices|
+        res << ext if LOCK.synchronize{choices.dup}.any? { |klass, file| template_class.to_s == klass }
       end
+      res.uniq!
       res
     end
 
@@ -193,40 +300,30 @@ module Tilt
 
     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]
+      LOCK.synchronize{@lazy_map.has_key?(ext) && !@lazy_map[ext].empty?}
     end
 
     def lookup(ext)
-      @template_map[ext] || lazy_load(ext)
+      LOCK.synchronize{@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|
+    def register_defined_classes(class_names, pattern)
+      class_names.each do |class_name|
         template_class = constant_defined?(class_name)
         if template_class
           register(template_class, pattern)
-          return template_class
+          yield template_class if block_given?
         end
       end
+    end
+
+    def lazy_load(pattern)
+      choices = LOCK.synchronize{@lazy_map[pattern].dup}
+
+      # Check if a template class is already present
+      register_defined_classes(choices.map(&:first), pattern) do |template_class|
+        return template_class
+      end
 
       first_failure = nil
 
@@ -234,12 +331,6 @@ module Tilt
       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)
@@ -251,15 +342,71 @@ module Tilt
         end
       end
 
-      raise first_failure if first_failure
+      raise first_failure
     end
 
+    # 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|
-        return false unless scope.const_defined?(n)
-        return false if scope.autoload?(n) # skip autload
+        return false if scope.autoload?(n) || !scope.const_defined?(n)
         scope.const_get(n)
       end
     end
   end
+
+  # Private internal class for finalized mappings, which are frozen and
+  # cannot be modified.
+  class FinalizedMapping < BaseMapping
+    # Set the template map to use.  The template map should already
+    # be frozen, but this is an internal class, so it does not
+    # explicitly check for that.
+    def initialize(template_map)
+      @template_map = template_map
+      freeze
+    end
+
+    # Returns receiver, since instances are always frozen.
+    def dup
+      self
+    end
+
+    # Returns receiver, since instances are always frozen.
+    def clone(freeze: false)
+      self
+    end
+
+    # Return whether the given file extension has been registered.
+    def registered?(ext)
+      @template_map.has_key?(ext.downcase)
+    end
+
+    # Returns an aarry of all extensions the template class will
+    # be used for.
+    def extensions_for(template_class)
+      res = []
+      @template_map.each do |ext, klass|
+        res << ext if template_class == klass
+      end
+      res.uniq!
+      res
+    end
+
+    private
+
+    def lookup(ext)
+      @template_map[ext]
+    end
+  end
+  private_constant :FinalizedMapping
 end

data/lib/tilt/markaby.rb

@@ -1,4 +1,5 @@
-require 'tilt/template'
+# frozen_string_literal: true
+require_relative 'template'
 require 'markaby'
 
 module Tilt
@@ -15,19 +16,16 @@ module Tilt
       end
     end
 
-    def prepare
-    end
-
     def evaluate(scope, locals, &block)
       builder = self.class.builder_class.new({}, scope)
       builder.locals = locals
 
-      if data.kind_of? Proc
-        (class << builder; self end).send(:define_method, :__run_markaby_tilt__, &data)
+      if @data.kind_of? Proc
+        (class << builder; self end).send(:define_method, :__run_markaby_tilt__, &@data)
       else
         builder.instance_eval <<-CODE, __FILE__, __LINE__
           def __run_markaby_tilt__
-            #{data}
+            #{@data}
           end
         CODE
       end

data/lib/tilt/maruku.rb

@@ -1,22 +1,10 @@
-require 'tilt/template'
+# frozen_string_literal: true
+require_relative '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
+warn 'tilt/maruku is deprecated, as maruku requires modifying string literals', uplevel: 1
 
-    def evaluate(scope, locals, &block)
-      @output ||= @engine.to_html
-    end
-
-    def allows_script?
-      false
-    end
-  end
+# Maruku markdown implementation. See: https://github.com/bhollis/maruku
+Tilt::MarukuTemplate = Tilt::StaticTemplate.subclass do
+  Maruku.new(@data, @options).to_html
 end
-

data/lib/tilt/nokogiri.rb

@@ -1,21 +1,23 @@
-require 'tilt/template'
+# frozen_string_literal: true
+require_relative 'template'
 require 'nokogiri'
 
 module Tilt
   # Nokogiri template implementation. See:
   # http://nokogiri.org/
   class NokogiriTemplate < Template
-    DOCUMENT_HEADER = /^<\?xml version=\"1\.0\"\?>\n?/
+    DOCUMENT_HEADER = /\A<\?xml version=\"1\.0\"\?>\n?/
     self.default_mime_type = 'text/xml'
 
-    def prepare; end
-
     def evaluate(scope, locals)
-      if data.respond_to?(:to_str)
-        wrapper = proc { yield.sub(DOCUMENT_HEADER, "") } if block_given?
-        super(scope, locals, &wrapper)
+      if @data.respond_to?(:to_str)
+        if block_given?
+          super(scope, locals){yield.sub(DOCUMENT_HEADER, "")}
+        else
+          super
+        end
       else
-        ::Nokogiri::XML::Builder.new.tap(&data).to_xml
+        ::Nokogiri::XML::Builder.new(&@data).to_xml
       end
     end
 
@@ -29,8 +31,7 @@ module Tilt
     end
 
     def precompiled_template(locals)
-      data.to_str
+      @data.to_str
     end
   end
 end
-

data/lib/tilt/pandoc.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+require_relative 'template'
+require 'pandoc-ruby'
+
+# Pandoc markdown implementation. See: http://pandoc.org/
+Tilt::PandocTemplate = Tilt::StaticTemplate.subclass do
+  # 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
+  pandoc_options = []
+  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
+        pandoc_options << k
+      when false
+        # do nothing
+      else
+        pandoc_options << { k => v }
+      end
+    end
+  end
+  pandoc_options << { :f => from + smart_extension }
+
+  PandocRuby.new(@data, *pandoc_options).to_html.strip
+end

data/lib/tilt/pipeline.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+require_relative 'template'
+
+module Tilt
+  # Superclass used for pipeline templates.  Should not be used directly.
+  class Pipeline < Template
+    def prepare
+      @pipeline = self.class::TEMPLATES.inject(proc{|*| data}) do |data, (klass, options)|
+        proc do |s,l,&sb|
+          klass.new(file, line, options, &proc{|*| data.call(s, l, &sb)}).render(s, l, &sb)
+        end
+      end
+    end
+
+    def evaluate(scope, locals, &block)
+      @pipeline.call(scope, locals, &block)
+    end
+  end
+end

data/lib/tilt/plain.rb

@@ -1,20 +1,5 @@
-require 'tilt/template'
+# frozen_string_literal: true
+require_relative '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
+# Raw text (no template functionality).
+Tilt::PlainTemplate = Tilt::StaticTemplate.subclass{@data}

data/lib/tilt/prawn.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+require_relative 'template'
+require 'prawn'
+
+module Tilt
+  # Prawn template implementation. See: http://prawnpdf.org
+  class PrawnTemplate < Template
+    self.default_mime_type = 'application/pdf'
+    
+    def prepare
+      @options[:page_size] = 'A4' unless @options.has_key?(:page_size)
+      @options[:page_layout] = :portrait unless @options.has_key?(:page_layout)
+      @engine = ::Prawn::Document.new(@options)
+    end
+    
+    def evaluate(scope, locals, &block)
+      pdf = @engine
+      locals = locals.dup
+      locals[:pdf] = pdf
+      super
+      pdf.render
+    end
+    
+    def precompiled_template(locals)
+      @data.to_str
+    end
+  end
+end