tilt 2.2.0 → 2.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0b933744ac3dc007d759af22c61ea725d84e6d83a689c07e384792d08f330f60
-  data.tar.gz: b07ad772a645934f3c0f912d2864eb9b47964b423a83d3cbc7978e6c90385229
+  metadata.gz: c7d6bc14bd4e47e94393d385285b1e147bcd06eac37dbcc8549b9d34b3513d2c
+  data.tar.gz: b4c7d8bffee3d9002adca1498b3f132629d82f7b5b05414914fdfcf44cc15c93
 SHA512:
-  metadata.gz: 17e9ff63c011271c8fceb20c08f1c3d36f85c6674608690575ffc08b79b5d9704c0d63e456c00a2a0207295f54ef8c5df9f59c5de71680b1bf018faee93cba26
-  data.tar.gz: fcffaeed7fba1e7f2bd9ec25f57426d544281cd434f8138253f5046f47e73a871770b4e8be1cb08349462b988a6101bbbca1f7ecc273bd74f457271eb3a84aa9
+  metadata.gz: 0325d0761536f88b597e37a2bf5e6fa467f35ce7ced1921f1912a25c85492cbddcb3ed27811beb6f7fe09f3dc302104da199f662ca6ed92d4b303dfce2f96d64
+  data.tar.gz: a82be500d86a6f2df1de115bee8f506033b3679f838d3416e21f0773539d5eda3ab73d49c46d7fd2189bfaeaa0d26cb568d66123b96682a96c6604efe23461c3

data/lib/tilt/coffee.rb

@@ -15,18 +15,6 @@ module Tilt
       attr_accessor :default_bare
     end
 
-    # :nocov:
-    def self.default_no_wrap
-      warn "#{self.class}.default_no_wrap is deprecated and will be removed in Tilt 2.3.  Switch to #{self.class}.default_bare."
-      default_bare
-    end
-
-    def self.default_no_wrap=(value)
-      warn "#{self.class}.default_no_wrap= is deprecated and will be removed in Tilt 2.3.  Switch to #{self.class}.default_bare=."
-      self.default_bare = value
-    end
-    # :nocov:
-
     def self.literate?
       false
     end

data/lib/tilt/commonmarker.rb

@@ -2,53 +2,94 @@
 require_relative 'template'
 require 'commonmarker'
 
-aliases = {
-  :smartypants => :SMART
-}.freeze
-parse_opts = [
-  :FOOTNOTES,
-  :LIBERAL_HTML_TAG,
-  :SMART,
-  :smartypants,
-  :STRIKETHROUGH_DOUBLE_TILDE,
-  :UNSAFE,
-  :VALIDATE_UTF8,
-].freeze
-render_opts = [
-  :FOOTNOTES,
-  :FULL_INFO_STRING,
-  :GITHUB_PRE_LANG,
-  :HARDBREAKS,
-  :NOBREAKS,
-  :SAFE, # Removed in v0.18.0 (2018-10-17)
-  :SOURCEPOS,
-  :TABLE_PREFER_STYLE_ATTRIBUTES,
-  :UNSAFE,
-].freeze
-exts = [
-  :autolink,
-  :strikethrough,
-  :table,
-  :tagfilter,
-  :tasklist,
-].freeze
+if defined?(::Commonmarker)
+  aliases = {
+    :smartypants => :smart
+  }.freeze
+  parse_opts = [
+    :smart,
+    :default_info_string,
+  ].freeze
+  render_opts = [
+    :hardbreaks,
+    :github_pre_lang,
+    :width,
+    :unsafe,
+    :escape,
+    :sourcepos,
+  ].freeze
+  exts = [
+    :strikethrough,
+    :tagfilter,
+    :table,
+    :autolink,
+    :tasklist,
+    :superscript,
+    :header_ids,
+    :footnotes,
+    :description_lists,
+    :front_matter_delimiter,
+    :shortcodes,
+  ].freeze
 
+  Tilt::CommonMarkerTemplate = Tilt::StaticTemplate.subclass do
+    parse_options = @options.select { |key, _| parse_opts.include?(key.downcase) }.transform_keys(&:downcase)
+    parse_options.merge!(@options.select { |key, _| aliases.has_key?(key) }.transform_keys { |key| aliases[key] })
+    render_options = @options.select { |key, _| render_opts.include?(key.downcase) }.transform_keys(&:downcase)
+    extensions = @options.select { |key, _| exts.include?(key) }.transform_keys(&:downcase)
 
-Tilt::CommonMarkerTemplate = Tilt::StaticTemplate.subclass do
-  extensions = exts.select do |extension|
-    @options[extension]
+    Commonmarker.to_html(@data, options: { parse: parse_options, render: render_options, extension: extensions })
   end
+# :nocov:
+else
+  aliases = {
+    :smartypants => :SMART
+  }.freeze
+  parse_opts = [
+    :FOOTNOTES,
+    :LIBERAL_HTML_TAG,
+    :SMART,
+    :smartypants,
+    :STRIKETHROUGH_DOUBLE_TILDE,
+    :UNSAFE,
+    :VALIDATE_UTF8,
+  ].freeze
+  render_opts = [
+    :FOOTNOTES,
+    :FULL_INFO_STRING,
+    :GITHUB_PRE_LANG,
+    :HARDBREAKS,
+    :NOBREAKS,
+    :SAFE, # Removed in v0.18.0 (2018-10-17)
+    :SOURCEPOS,
+    :TABLE_PREFER_STYLE_ATTRIBUTES,
+    :UNSAFE,
+  ].freeze
+  exts = [
+    :autolink,
+    :strikethrough,
+    :table,
+    :tagfilter,
+    :tasklist,
+  ].freeze
 
-  parse_options, render_options = [parse_opts, render_opts].map do |opts|
-    opts = opts.select do |option|
-      @options[option]
-    end.map! do |option|
-      aliases[option] || option
+  Tilt::CommonMarkerTemplate = Tilt::StaticTemplate.subclass do
+    extensions = exts.select do |extension|
+      @options[extension]
     end
 
-    opts = :DEFAULT unless opts.any?
-    opts
-  end
+    parse_options, render_options = [parse_opts, render_opts].map do |opts|
+      opts = opts.select do |option|
+        @options[option]
+      end.map! do |option|
+        aliases[option] || option
+      end
+
+      opts = :DEFAULT unless opts.any?
+      opts
+    end
 
-  CommonMarker.render_doc(@data, parse_options, extensions).to_html(render_options, extensions)
+    CommonMarker.render_doc(@data, parse_options, extensions).to_html(render_options, extensions)
+  end
 end
+# :nocov:

data/lib/tilt/creole.rb

@@ -2,6 +2,8 @@
 require_relative 'template'
 require 'creole'
 
+warn 'tilt/creole is deprecated, as creole requires modifying string literals', uplevel: 1
+
 allowed_opts = [:allowed_schemes, :extensions, :no_escape].freeze
 
 # Creole implementation. See: http://www.wikicreole.org/

data/lib/tilt/erb.rb

@@ -8,23 +8,9 @@ module Tilt
   class ERBTemplate < Template
     SUPPORTS_KVARGS = ::ERB.instance_method(:initialize).parameters.assoc(:key) rescue false
 
-    # Remove in Tilt 2.3
-    @default_output_variable = nil
-    def self._default_output_variable
-      @default_output_variable
-    end
-    def self.default_output_variable
-      warn "#{self}.default_output_variable is deprecated and will be removed in Tilt 2.3.", uplevel: 1
-      @default_output_variable
-    end
-    def self.default_output_variable=(name)
-      warn "#{self}.default_output_variable= is deprecated and will be removed in Tilt 2.3. Switch to using the :outvar option.", uplevel: 1
-      @default_output_variable = name
-    end
-
     def prepare
       @freeze_string_literals = !!@options[:freeze]
-      @outvar = @options[:outvar] || self.class._default_output_variable || '_erbout'
+      @outvar = @options[:outvar] || '_erbout'
       trim = case @options[:trim]
       when false
         nil

data/lib/tilt/etanni.rb

@@ -5,7 +5,7 @@ module Tilt
   class EtanniTemplate < Template
     def prepare
       separator = data.hash.abs
-      chomp = "<<#{separator}.chomp!"
+      chomp = "<<#{separator}.chomp"
       start = "\n_out_ << #{chomp}\n"
       stop = "\n#{separator}\n"
       replacement = "#{stop}\\1#{start}"
@@ -13,7 +13,7 @@ module Tilt
       temp = @data.strip
       temp.gsub!(/<\?r\s+(.*?)\s+\?>/m, replacement)
 
-      @code = "_out_ = [<<#{separator}.chomp!]\n#{temp}#{stop}_out_.join"
+      @code = "_out_ = [<<#{separator}.chomp]\n#{temp}#{stop}_out_.join"
     end
 
     def precompiled_template(locals)

data/lib/tilt/liquid.rb

@@ -13,9 +13,6 @@ module Tilt
   # to #to_h it will be ignored.
   #
   # LiquidTemplate does not support yield blocks.
-  #
-  # It's suggested that your program require 'liquid' at load
-  # time when using this template engine.
   class LiquidTemplate < Template
     def prepare
       @options[:line_numbers] = true unless @options.has_key?(:line_numbers)

data/lib/tilt/mapping.rb

@@ -113,14 +113,14 @@ module Tilt
   # the exception of the first, since that was the most preferred one.
   #
   #     mapping = Tilt::Mapping.new
-  #     mapping.register_lazy('Maruku::Template', 'maruku/template', 'md')
+  #     mapping.register_lazy('Kramdown::Template', 'kramdown/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
-  # Maruku. Tilt will first try to `require "rdiscount/template"`, falling
-  # back to `require "maruku/template"`. If none of these are successful,
+  # Kramdown. Tilt will first try to `require "rdiscount/template"`, falling
+  # back to `require "kramdown/template"`. If none of these are successful,
   # the first error will be raised.
   class Mapping < BaseMapping
     LOCK = Mutex.new

data/lib/tilt/prawn.rb

@@ -15,16 +15,9 @@ module Tilt
     
     def evaluate(scope, locals, &block)
       pdf = @engine
-      if @data.respond_to?(:to_str)
-        locals = locals.dup
-        locals[:pdf] = pdf
-        super
-      else
-        warn "Non-string provided as prawn template data. This is no longer supported and support for it will be removed in Tilt 2.3", :uplevel=>2
-        # :nocov:
-        @data.call(pdf) if @data.kind_of?(Proc)
-        # :nocov:
-      end
+      locals = locals.dup
+      locals[:pdf] = pdf
+      super
       pdf.render
     end
     

data/lib/tilt/rdoc.rb

@@ -6,14 +6,6 @@ require 'rdoc/markup/to_html'
 require 'rdoc/options'
 
 # RDoc template. See: https://github.com/ruby/rdoc
-#
-# It's suggested that your program run the following at load time when
-# using this templae engine in a threaded environment:
-#
-#   require 'rdoc'
-#   require 'rdoc/markup'
-#   require 'rdoc/markup/to_html'
-#   require 'rdoc/options'
 Tilt::RDocTemplate = Tilt::StaticTemplate.subclass do
   RDoc::Markup::ToHtml.new(RDoc::Options.new, nil).convert(@data).to_s
 end

data/lib/tilt/redcarpet.rb

@@ -4,41 +4,28 @@ require 'redcarpet'
 
 aliases = {:escape_html => :filter_html, :smartypants => :smart}.freeze
 
-# :nocov:
-unless defined? ::Redcarpet::Render and defined? ::Redcarpet::Markdown
-  # Redcarpet 1.x
-  warn "Tilt support for RedCarpet 1.x is deprecated and will be removed in Tilt 2.3", uplevel: 1
-  _flags = [:smart, :filter_html, :smartypants, :escape_html]
-
-  Tilt::RedcarpetTemplate = Tilt::StaticTemplate.subclass do
-    flags = _flags.select { |flag| @options[flag] }.map! { |flag| aliases[flag] || flag }
-    RedcarpetCompat.new(@data, *flags).to_html
-  end
-# :nocov:
-else
-  Tilt::RedcarpetTemplate = Tilt::StaticTemplate.subclass do
-    aliases.each do |opt, aka|
-      if options.key?(aka) || !@options.key?(opt)
-        @options[opt] = @options.delete(aka)
-      end
+Tilt::RedcarpetTemplate = Tilt::StaticTemplate.subclass do
+  aliases.each do |opt, aka|
+    if options.key?(aka) || !@options.key?(opt)
+      @options[opt] = @options.delete(aka)
     end
+  end
 
-    # only raise an exception if someone is trying to enable :escape_html
-    @options.delete(:escape_html) unless @options[:escape_html]
+  # only raise an exception if someone is trying to enable :escape_html
+  @options.delete(:escape_html) unless @options[:escape_html]
 
-    renderer = @options.delete(:renderer) || ::Redcarpet::Render::HTML.new(@options)
-    if options.delete(:smartypants) && !(renderer.is_a?(Class) && renderer <= ::Redcarpet::Render::SmartyPants)
-      renderer = 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
+  renderer = @options.delete(:renderer) || ::Redcarpet::Render::HTML.new(@options)
+  if options.delete(:smartypants) && !(renderer.is_a?(Class) && renderer <= ::Redcarpet::Render::SmartyPants)
+    renderer = 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
-
-    Redcarpet::Markdown.new(renderer, @options).render(@data)
   end
+
+  Redcarpet::Markdown.new(renderer, @options).render(@data)
 end

data/lib/tilt/sass.rb

@@ -13,6 +13,13 @@ module Tilt
     # :nocov:
       require 'uri'
 
+      ALLOWED_KEYS = (defined?(::Sass::Compiler) ? ::Sass::Compiler : ::Sass::Embedded).
+        instance_method(:compile_string).
+        parameters.
+        map{|k, v| v if k == :key}.
+        compact rescue nil
+      private_constant :ALLOWED_KEYS
+
       private
 
       def _prepare_output
@@ -22,9 +29,11 @@ module Tilt
       def sass_options
         path = File.absolute_path(eval_file)
         path = '/' + path unless path.start_with?('/')
-        @options[:url] = ::URI::File.build([nil, ::URI::DEFAULT_PARSER.escape(path)]).to_s
-        @options[:syntax] = :indented
-        @options
+        opts = @options.dup
+        opts[:url] = ::URI::File.build([nil, ::URI::DEFAULT_PARSER.escape(path)]).to_s
+        opts[:syntax] = :indented
+        opts.delete_if{|k| !ALLOWED_KEYS.include?(k)} if ALLOWED_KEYS
+        opts
       end
     rescue LoadError => err
       begin
@@ -61,9 +70,9 @@ module Tilt
     private
 
     def sass_options
-      super
-      @options[:syntax] = :scss
-      @options
+      opts = super
+      opts[:syntax] = :scss
+      opts
     end
   end
 end

data/lib/tilt/string.rb

@@ -7,6 +7,7 @@ module Tilt
   class StringTemplate < Template
     def prepare
       hash = "TILT#{@data.hash.abs}"
+      @freeze_string_literals = !!@options[:freeze]
       @code = String.new("<<#{hash}.chomp\n#{@data}\n#{hash}")
     end
 
@@ -18,5 +19,9 @@ module Tilt
       source, offset = super
       [source, offset + 1]
     end
+
+    def freeze_string_literals?
+      @freeze_string_literals
+    end
   end
 end

data/lib/tilt/template.rb

@@ -57,7 +57,28 @@ module Tilt
     # it should read template data and return as a String. When file is nil,
     # a block is required.
     #
-    # All arguments are optional.
+    # All arguments are optional. The following options are respected and
+    # are used by Tilt::Template itself and not the underlying template
+    # libraries:
+    #
+    # :default_encoding :: Force the encoding of the template to the given
+    #                      encoding.
+    # :skip_compiled_encoding_detection :: Do not scan template code for
+    #                                      an encoding magic comment.
+    # :fixed_locals :: Force a specific method parameter signature, and call
+    #                  the method with a splat of locals, instead of passing
+    #                  the locals hash as a positional argument, and
+    #                  extracting locals from that. Should be a string
+    #                  containing the parameters for the compiled method,
+    #                  surrounded by parentheses.  Can be set to false to
+    #                  disable the scan for embedded fixed locals.
+    # :extract_fixed_locals :: Whether embedded fixed locals should be scanned for
+    #                          and extracted from the template code.
+    # :default_fixed_locals :: Similar to fixed_locals, but lowest priority,
+    #                          only used if :fixed_locals is not provided
+    #                          and no embedded locals are found (or scanned for).
+    # :scope_class :: Force the scope class used for the method.  By default,
+    #                 uses the class of the scope provided to render.
     def initialize(file=nil, line=nil, options=nil)
       @file, @line, @options = nil, 1, nil
 
@@ -69,7 +90,9 @@ module Tilt
 
       @options ||= {}
 
-      set_compiled_method_cache
+      # Force a specific scope class, instead of using the class of the provided
+      # scope as the scope class.
+      @scope_class = @options.delete :scope_class
 
       # Force the encoding of the input data
       @default_encoding = @options.delete :default_encoding
@@ -78,12 +101,19 @@ module Tilt
       # for compiled templates
       @skip_compiled_encoding_detection = @options.delete :skip_compiled_encoding_detection
 
+      # Compiled path to use.  This must be specified as an option if
+      # providing the :scope_class option and using fixed locals,
+      # since template compilation occurs during initialization in that case.
+      if compiled_path = @options.delete(:compiled_path)
+        self.compiled_path = compiled_path
+      end
+
       # load template data and prepare (uses binread to avoid encoding issues)
       @data = block_given? ? yield(self) : read_template_file
 
       if @data.respond_to?(:force_encoding)
         if default_encoding
-          @data = @data.dup if @data.frozen?
+          @data = _dup_string_if_frozen(@data)
           @data.force_encoding(default_encoding)
         end
 
@@ -92,18 +122,16 @@ module Tilt
         end
       end
 
+      set_fixed_locals
       prepare
+      set_compiled_method_cache
     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=nil, locals=nil, &block)
-      current_template = Thread.current[:tilt_current_template]
-      Thread.current[:tilt_current_template] = self
       evaluate(scope || Object.new, locals || EMPTY_HASH, &block)
-    ensure
-      Thread.current[:tilt_current_template] = current_template
     end
 
     # The basename of the template file.
@@ -123,6 +151,11 @@ module Tilt
       @file || '(__TEMPLATE__)'
     end
 
+    # Whether the template uses fixed locals.
+    def fixed_locals?
+      @fixed_locals ? true : false
+    end
+
     # An empty Hash that the template engine can populate with various
     # metadata.
     def metadata
@@ -133,7 +166,14 @@ module Tilt
       end
     end
 
-    # Set the prefix to use for compiled paths.
+    # Set the prefix to use for compiled paths, similar to using the
+    # :compiled_path template option. Note that this only
+    # has affect for future template compilations.  When using the
+    # :scope_class template option, and using fixed_locals, calling
+    # this after the template is created has no effect, since the
+    # template is compiled during initialization in that case. It
+    # is recommended to use the :compiled_path template option
+    # instead of this method in new code.
     def compiled_path=(path)
       if path
         # Use expanded paths when loading, since that is helpful
@@ -149,7 +189,18 @@ module Tilt
     # directly on the scope class, which are much faster to call than
     # Tilt's normal rendering.
     def compiled_method(locals_keys, scope_class=nil)
-      key = [scope_class, locals_keys].freeze
+      if @fixed_locals
+        if @scope_class
+          return @compiled_method
+        else
+          key = scope_class
+        end
+      elsif @scope_class
+        key = locals_keys.dup.freeze
+      else
+        key = [scope_class, locals_keys].freeze
+      end
+
       LOCK.synchronize do
         if meth = @compiled_method[key]
           return meth
@@ -185,7 +236,7 @@ module Tilt
     end
 
     CLASS_METHOD = Kernel.instance_method(:class)
-    USE_BIND_CALL = RUBY_VERSION >= '2.7'
+    USE_BIND_CALL = RUBY_VERSION >= '3'
 
     # Execute the compiled template and return the result string. Template
     # evaluation is guaranteed to be performed in the scope object with the
@@ -194,26 +245,25 @@ module Tilt
     # This method is only used by source generating templates. Subclasses that
     # override render() may not support all features.
     def evaluate(scope, locals, &block)
-      locals_keys = locals.keys
-      locals_keys.sort!{|x, y| x.to_s <=> y.to_s}
-
-      case scope
-      when Object
-        scope_class = Module === scope ? scope : scope.class
+      if @fixed_locals
+        locals_keys = EMPTY_ARRAY
       else
-        # :nocov:
-        scope_class = USE_BIND_CALL ? CLASS_METHOD.bind_call(scope) : CLASS_METHOD.bind(scope).call
-        # :nocov:
+        locals_keys = locals.keys
+        locals_keys.sort!{|x, y| x.to_s <=> y.to_s}
       end
-      method = compiled_method(locals_keys, scope_class)
 
-      if USE_BIND_CALL
-        method.bind_call(scope, locals, &block)
-      # :nocov:
-      else
-        method.bind(scope).call(locals, &block)
-      # :nocov:
+      unless scope_class = @scope_class
+        scope_class = case scope
+        when Object
+          Module === scope ? scope : scope.class
+        else
+          # :nocov:
+          USE_BIND_CALL ? CLASS_METHOD.bind_call(scope) : CLASS_METHOD.bind(scope).call
+          # :nocov:
+        end
       end
+
+      evaluate_method(compiled_method(locals_keys, scope_class), scope, locals, &block)
     end
 
     # Generates all template source by combining the preamble, template, and
@@ -271,6 +321,18 @@ module Tilt
 
     private
 
+    if RUBY_VERSION >= '2.3'
+      def _dup_string_if_frozen(string)
+        +string
+      end
+    # :nocov:
+    else
+      def _dup_string_if_frozen(string)
+        string.frozen? ? string.dup : string
+      end
+    end
+    # :nocov:
+
     def process_arg(arg)
       if arg
         case
@@ -295,7 +357,12 @@ module Tilt
     end
 
     def set_compiled_method_cache
-      @compiled_method = {}
+      @compiled_method = if @fixed_locals && @scope_class
+        # No hash needed, only a single compiled method per template.
+        compile_template_method(EMPTY_ARRAY, @scope_class)
+      else
+        {}
+      end
     end
 
     def local_extraction(local_keys)
@@ -319,9 +386,39 @@ module Tilt
       assignments.join("\n")
     end
 
+    if USE_BIND_CALL
+      def evaluate_method(method, scope, locals, &block)
+        if @fixed_locals
+          method.bind_call(scope, **locals, &block)
+        else
+          method.bind_call(scope, locals, &block)
+        end
+      end
+    # :nocov:
+    else
+      def evaluate_method(method, scope, locals, &block)
+        if @fixed_locals
+          if locals.empty?
+            # Empty keyword splat on Ruby 2.0-2.6 passes empty hash
+            method.bind(scope).call(&block)
+          else
+            method.bind(scope).call(**locals, &block)
+          end
+        else
+          method.bind(scope).call(locals, &block)
+        end
+      end
+    end
+    # :nocov:
+
     def compile_template_method(local_keys, scope_class=nil)
       source, offset = precompiled(local_keys)
-      local_code = local_extraction(local_keys)
+      if @fixed_locals
+        method_args = @fixed_locals
+      else
+        method_args = "(locals)"
+        local_code = local_extraction(local_keys)
+      end
 
       method_name = "__tilt_#{Thread.current.object_id.abs}"
       method_source = String.new
@@ -332,7 +429,7 @@ module Tilt
       end
 
       # Don't indent method source, to avoid indentation warnings when using compiled paths
-      method_source << "::Tilt::TOPOBJECT.class_eval do\ndef #{method_name}(locals)\n#{local_code}\n"
+      method_source << "::Tilt::TOPOBJECT.class_eval do\ndef #{method_name}#{method_args}\n#{local_code}\n"
 
       offset += method_source.count("\n")
       method_source << source
@@ -355,7 +452,11 @@ module Tilt
         path << ".rb"
 
         # Wrap method source in a class block for the scope, so constant lookup works
-        method_source = "class #{scope_class.name}\n#{method_source}\nend"
+        if freeze_string_literals?
+          method_source_prefix = "# frozen-string-literal: true\n"
+          method_source = method_source.sub(/\A# frozen-string-literal: true\n/, '')
+        end
+        method_source = "#{method_source_prefix}class #{scope_class.name}\n#{method_source}\nend"
 
         load_compiled_method(path, method_source)
       else
@@ -372,7 +473,12 @@ module Tilt
     end
 
     def load_compiled_method(path, method_source)
-      File.binwrite(path, method_source)
+      # Write to a temporary path specific to the current process, and
+      # rename after writing. This prevents issues during parallel
+      # coverage testing.
+      tmp_path = "#{path}-#{$$}"
+      File.binwrite(tmp_path, method_source)
+      File.rename(tmp_path, path)
 
       # Use load and not require, so unbind_compiled_method does not
       # break if the same path is used more than once.
@@ -385,13 +491,49 @@ module Tilt
       method
     end
 
+    # Set the fixed locals for the template, which may be nil if no fixed locals can
+    # be determined.
+    def set_fixed_locals
+      fixed_locals = @options.delete(:fixed_locals)
+      extract_fixed_locals = @options.delete(:extract_fixed_locals)
+      default_fixed_locals = @options.delete(:default_fixed_locals)
+
+      if fixed_locals.nil?
+        if extract_fixed_locals.nil?
+          extract_fixed_locals = Tilt.extract_fixed_locals
+        end
+
+        if extract_fixed_locals
+          fixed_locals = extract_fixed_locals()
+        end
+
+        if fixed_locals.nil?
+          fixed_locals = default_fixed_locals
+        end
+      end
+
+      @fixed_locals = fixed_locals
+    end
+
+    # Extract fixed locals from the template code string. Should return nil
+    # if there are no fixed locals specified, or a method argument string
+    # surrounded by parentheses if there are fixed locals.  The method
+    # argument string will be used when defining the template method if given.
+    def extract_fixed_locals
+      if @data.is_a?(String) && (match = /\#\s*locals:\s*(\(.*\))/.match(@data))
+        match[1]
+      end
+    end
+
     def extract_encoding(script, &block)
       extract_magic_comment(script, &block) || script.encoding
     end
 
     def extract_magic_comment(script)
-      if script.frozen?
-        script = script.dup
+      was_frozen = script.frozen?
+      script = _dup_string_if_frozen(script)
+
+      if was_frozen
         yield script
       end
 
@@ -413,6 +555,16 @@ module Tilt
     end
   end
 
+  # Static templates are templates that return the same output for every render
+  #
+  # Instead of inheriting from the StaticTemplate class, you will use the .subclass
+  # method with a block which processes @data and returns the transformed value.
+  #
+  # Basic example which transforms the template to uppercase:
+  #
+  #   UppercaseTemplate = Tilt::StaticTemplate.subclass do
+  #     @data.upcase
+  #   end
   class StaticTemplate < Template
     def self.subclass(mime_type: 'text/html', &block)
       Class.new(self) do
@@ -451,5 +603,9 @@ module Tilt
     # Do nothing, since compiled method cache is not used.
     def set_compiled_method_cache
     end
+
+    # Do nothing, since fixed locals are not used.
+    def set_fixed_locals
+    end
   end
 end

data/lib/tilt.rb

@@ -5,12 +5,16 @@ require_relative 'tilt/template'
 # Namespace for Tilt. This module is not intended to be included anywhere.
 module Tilt
   # Current version.
-  VERSION = '2.2.0'
+  VERSION = '2.6.1'
+
+  EMPTY_ARRAY = [].freeze
+  private_constant :EMPTY_ARRAY
 
   EMPTY_HASH = {}.freeze
   private_constant :EMPTY_HASH
 
   @default_mapping = Mapping.new
+  @extract_fixed_locals = false
 
   # Replace the default mapping with a finalized version of the default
   # mapping. This can be done to improve performance after the template
@@ -18,6 +22,8 @@ module Tilt
   # is called, all attempts to modify the default mapping will fail.
   # This also freezes Tilt itself.
   def self.finalize!
+    return self if @default_mapping.is_a?(FinalizedMapping)
+
     class << self
       prepend(Module.new do
         def lazy_map(*)
@@ -80,23 +86,14 @@ module Tilt
     @default_mapping.templates_for(file)
   end
 
-  # @return the template object that is currently rendering.
-  #
-  # @example
-  #   tmpl = Tilt['index.erb'].new { '<%= Tilt.current_template %>' }
-  #   tmpl.render == tmpl.to_s
-  #
-  # @note This is currently an experimental feature and might return nil
-  #   in the future.
-  def self.current_template
-    warn "Tilt.current_template is deprecated and will be removed in Tilt 2.3", uplevel: 1
-    Thread.current[:tilt_current_template]
-  end
-
   class << self
     # @return [Tilt::Mapping] the main mapping object
     attr_reader :default_mapping
 
+    # Whether to extract fixed locals from templates by scanning the
+    # template content.
+    attr_accessor :extract_fixed_locals
+
     # Alias register as prefer for Tilt 1.x compatibility.
     alias prefer register
   end
@@ -150,11 +147,9 @@ module Tilt
 
   # ERB
   register_lazy :ERBTemplate,    'tilt/erb',    'erb', 'rhtml'
-  register_lazy :ErubisTemplate, 'tilt/erubis', 'erb', 'rhtml', 'erubis'
   register_lazy :ErubiTemplate,  'tilt/erubi',  'erb', 'rhtml', 'erubi'
 
   # Markdown
-  register_lazy :MarukuTemplate,       'tilt/maruku',       'markdown', 'mkd', 'md'
   register_lazy :KramdownTemplate,     'tilt/kramdown',     'markdown', 'mkd', 'md'
   register_lazy :RDiscountTemplate,    'tilt/rdiscount',    'markdown', 'mkd', 'md'
   register_lazy :RedcarpetTemplate,    'tilt/redcarpet',    'markdown', 'mkd', 'md'
@@ -186,7 +181,6 @@ module Tilt
   register_lazy :SlimTemplate,         'tilt/slim',      'slim'
   register_lazy :StringTemplate,       'tilt/string',    'str'
   register_lazy :TypeScriptTemplate,   'tilt/typescript', 'ts', 'tsx'
-  register_lazy :WikiClothTemplate,    'tilt/wikicloth', 'wiki', 'mediawiki', 'mw'
   register_lazy :YajlTemplate,         'tilt/yajl',      'yajl'
 
   # TILT3: Remove

metadata

@@ -1,16 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: tilt
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.6.1
 platform: ruby
 authors:
 - Ryan Tomayko
 - Magnus Holm
 - Jeremy Evans
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-06-05 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: Generic interface to multiple Ruby template engines
 email: code@jeremyevans.net
@@ -36,7 +35,6 @@ files:
 - lib/tilt/csv.rb
 - lib/tilt/erb.rb
 - lib/tilt/erubi.rb
-- lib/tilt/erubis.rb
 - lib/tilt/etanni.rb
 - lib/tilt/haml.rb
 - lib/tilt/kramdown.rb
@@ -44,7 +42,6 @@ files:
 - lib/tilt/livescript.rb
 - lib/tilt/mapping.rb
 - lib/tilt/markaby.rb
-- lib/tilt/maruku.rb
 - lib/tilt/nokogiri.rb
 - lib/tilt/pandoc.rb
 - lib/tilt/pipeline.rb
@@ -61,7 +58,6 @@ files:
 - lib/tilt/string.rb
 - lib/tilt/template.rb
 - lib/tilt/typescript.rb
-- lib/tilt/wikicloth.rb
 - lib/tilt/yajl.rb
 homepage: https://github.com/jeremyevans/tilt
 licenses:
@@ -71,7 +67,6 @@ metadata:
   changelog_uri: https://github.com/jeremyevans/tilt/blob/master/CHANGELOG.md
   mailing_list_uri: https://github.com/jeremyevans/tilt/discussions
   source_code_uri: https://github.com/jeremyevans/tilt
-post_install_message:
 rdoc_options:
 - "--line-numbers"
 - "--inline-source"
@@ -92,8 +87,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
-signing_key:
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Generic interface to multiple Ruby template engines
 test_files: []

data/lib/tilt/erubis.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-require_relative '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
-    # Remove in Tilt 2.3
-    @default_output_variable = nil
-
-    def prepare
-      @freeze_string_literals = !!@options.delete(:freeze)
-      @outvar = @options.delete(:outvar) || self.class._default_output_variable  || '_erbout'
-      @options[:preamble] = false
-      @options[:postamble] = false
-      @options[: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 = String.new"].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.
-    def precompiled(locals)
-      source, offset = super
-      [source, offset - 1]
-    end
-
-    def freeze_string_literals?
-      @freeze_string_literals
-    end
-  end
-end

data/lib/tilt/maruku.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-require_relative 'template'
-require 'maruku'
-
-# 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/wikicloth.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-require_relative 'template'
-require 'wikicloth'
-
-# WikiCloth implementation. See: https://github.com/nricciar/wikicloth
-Tilt::WikiClothTemplate = Tilt::StaticTemplate.subclass do
-  parser = @options.delete(:parser) || WikiCloth::Parser
-  @options[:data] = @data
-  parser.new(@options).to_html
-end