tilt 2.0.11 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a552c8551a7093b787234c00bac7ccaaef77e89b1d4835c31ddbaeb8388c74ae
-  data.tar.gz: 014cff88cd5ec4157d02127576eb788a6b0ae3795e69dc448781093f59153769
+  metadata.gz: 837e8836cd6aacedb861823faead2fd72549f1c750e2f0350471303c1ca5cab3
+  data.tar.gz: 578c1873d63eb0e2426e2c86199f414f516952562c85ee9e91e0907a936603b9
 SHA512:
-  metadata.gz: 9d9da743f0359f10e8486b946132d39ba892482a99e7961c4a62258a680a214030824e92442db2421f35cac7c4378ff3e8e8e0af72bd8af35150aae2cc58555b
-  data.tar.gz: 2755a44a43e094eb95bffe6ab095f4d8a6cc1b58d1c96d6c20325d8d607ada32da7529758dfed8f8d8f09a3eafe2c7d96f381c314c7cc99f950a36c5eaff3454
+  metadata.gz: a63e7b55aacbe374f70317cddd821c065ae512622be8f20bc25aeb2aabd5455d91cb7d97894de420f3bfb4f7c571c5f832047db182bb35107fd6d566879c04d7
+  data.tar.gz: 2c2785a08edb15f9e593a1b717682212f5a50f1f6694c02256179ee15c9a1e73429a5c6ae804e83611cc645209330c36ea117c6d38698f0021e2a7d748c59919

data/lib/tilt/bluecloth.rb

@@ -1,6 +1,8 @@
 require 'tilt/template'
 require 'bluecloth'
 
+warn "Tilt::BlueClothTemplate is deprecated, please switch to a different markdown implementation"
+
 module Tilt
   # BlueCloth Markdown implementation. See:
   # http://deveiate.org/projects/BlueCloth/

data/lib/tilt/csv.rb

@@ -1,10 +1,5 @@
 require 'tilt/template'
-
-if RUBY_VERSION >= '1.9.0'
-  require 'csv'
-else
-  require 'fastercsv'
-end
+require 'csv'
 
 module Tilt
 
@@ -36,21 +31,13 @@ module Tilt
   class CSVTemplate < Template
     self.default_mime_type = 'text/csv'
 
-    def self.engine
-      if RUBY_VERSION >= '1.9.0' && defined? ::CSV
-        ::CSV
-      elsif defined? ::FasterCSV
-        ::FasterCSV 
-      end
-    end
-
     def prepare
       @outvar = options.delete(:outvar) || '_csvout'
     end
 
     def precompiled_template(locals)
       <<-RUBY
-        #{@outvar} = #{self.class.engine}.generate(**#{options}) do |csv|
+        #{@outvar} = CSV.generate(**#{options}) do |csv|
           #{data}
         end
       RUBY

data/lib/tilt/erb.rb

@@ -19,12 +19,20 @@ module Tilt
     end
 
     def prepare
+      @freeze_string_literals = !!@options[:freeze]
       @outvar = options[:outvar] || self.class.default_output_variable
-      options[:trim] = '<>' if !(options[:trim] == false) && (options[:trim].nil? || options[:trim] == true)
+      trim = case options[:trim]
+      when false
+        nil
+      when nil, true
+        '<>'
+      else
+        options[:trim]
+      end
       @engine = if SUPPORTS_KVARGS
-        ::ERB.new(data, trim_mode: options[:trim], eoutvar: @outvar)
+        ::ERB.new(data, trim_mode: trim, eoutvar: @outvar)
       else
-        ::ERB.new(data, options[:safe], options[:trim], @outvar)
+        ::ERB.new(data, options[:safe], trim, @outvar)
       end
     end
 
@@ -52,11 +60,13 @@ module Tilt
 
     # ERB generates a line to specify the character coding of the generated
     # source in 1.9. Account for this in the line offset.
-    if RUBY_VERSION >= '1.9.0'
-      def precompiled(locals)
-        source, offset = super
-        [source, offset + 1]
-      end
+    def precompiled(locals)
+      source, offset = super
+      [source, offset + 1]
+    end
+
+    def freeze_string_literals?
+      @freeze_string_literals
     end
   end
 end

data/lib/tilt/erubi.rb

@@ -16,6 +16,24 @@ module Tilt
 
       engine_class = @options[:engine_class] || Erubi::Engine
 
+      # If :freeze option is given, the intent is to setup frozen string
+      # literals in the template.  So enable frozen string literals in the
+      # code Tilt generates if the :freeze option is given.
+      if @freeze_string_literals = !!@options[:freeze]
+        # Passing the :freeze option to Erubi sets the
+        # frozen-string-literal magic comment, which doesn't have an effect
+        # with Tilt as Tilt wraps the resulting code.  Worse, the magic
+        # comment appearing not at the top of the file can cause a warning.
+        # So remove the :freeze option before passing to Erubi.
+        @options.delete(:freeze)
+
+        # Erubi by default appends .freeze to template literals on Ruby 2.1+,
+        # but that is not necessary and slows down code when Tilt is using
+        # frozen string literals, so pass the :freeze_template_literals
+        # option to not append .freeze.
+        @options[:freeze_template_literals] = false
+      end
+
       @engine = engine_class.new(data, @options)
       @outvar = @engine.bufvar
 
@@ -28,5 +46,9 @@ module Tilt
     def precompiled_template(locals)
       @src
     end
+
+    def freeze_string_literals?
+      @freeze_string_literals
+    end
   end
 end

data/lib/tilt/erubis.rb

@@ -16,6 +16,7 @@ module Tilt
   #                   within <%= %> blocks will be automatically html escaped.
   class ErubisTemplate < ERBTemplate
     def prepare
+      @freeze_string_literals = !!@options.delete(:freeze)
       @outvar = options.delete(:outvar) || self.class.default_output_variable
       @options.merge!(:preamble => false, :postamble => false, :bufvar => @outvar)
       engine_class = options.delete(:engine_class)
@@ -33,11 +34,13 @@ module Tilt
 
     # 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
+    def precompiled(locals)
+      source, offset = super
+      [source, offset - 1]
+    end
+
+    def freeze_string_literals?
+      @freeze_string_literals
     end
   end
 end

data/lib/tilt/haml.rb

@@ -4,81 +4,86 @@ require 'haml'
 module Tilt
   # Haml template implementation. See:
   # http://haml.hamptoncatlin.com/
-  class HamlTemplate < Template
-    self.default_mime_type = 'text/html'
+  if defined?(Haml::Template) && Haml::Template < Tilt::Template
+    # Haml >= 6 ships its own template, prefer it when available.
+    HamlTemplate = Haml::Template
+  else
+    class HamlTemplate < Template
+      self.default_mime_type = 'text/html'
 
-    # `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
+      # `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
-        @engine = ::Haml::TempleEngine.new(options)
-        @engine.compile(data)
-      end
 
-      def evaluate(scope, locals, &block)
-        raise ArgumentError, 'invalid scope: must not be frozen' if scope.frozen?
-        super
-      end
+        def evaluate(scope, locals, &block)
+          raise ArgumentError, 'invalid scope: must not be frozen' if scope.frozen?
+          super
+        end
 
-      def precompiled_template(locals)
-        @engine.precompiled_with_ambles(
-          [],
-          after_preamble: <<-RUBY
-            __in_erb_template = true
-            _haml_locals = locals
-          RUBY
-        )
-      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 precompiled_template(locals)
+          @engine.precompiled_with_ambles(
+            [],
+            after_preamble: <<-RUBY
+              __in_erb_template = true
+              _haml_locals = locals
+            RUBY
+          )
+        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 evaluate(scope, locals, &block)
+          raise ArgumentError, 'invalid scope: must not be frozen' if scope.frozen?
 
-        if @engine.respond_to?(:precompiled_method_return_value, true)
-          super
-        else
-          @engine.render(scope, locals, &block)
+          if @engine.respond_to?(:precompiled_method_return_value, true)
+            super
+          else
+            @engine.render(scope, locals, &block)
+          end
         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
+        # 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
+        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
-      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
+        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

data/lib/tilt/less.rb

@@ -1,6 +1,8 @@
 require 'tilt/template'
 require 'less'
 
+warn "Tilt::LessTemplate is deprecated, consider switching from LESS to SCSS"
+
 module Tilt
   # Lessscss template implementation. See:
   # http://lesscss.org/

data/lib/tilt/mapping.rb

@@ -1,4 +1,5 @@
 require 'monitor'
+require_relative 'pipeline'
 
 module Tilt
   # Tilt::Mapping associates file extensions with template implementations.
@@ -112,6 +113,62 @@ module Tilt
       end
     end
 
+    # 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.
+    #
+    # 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.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={})
+      templates = options[:templates] || ext.split('.').reverse
+      templates = templates.map{|t| [self[t], options[t] || {}]}
+
+      klass = Class.new(Pipeline)
+      klass.send(:const_set, :TEMPLATES, templates)
+
+      register(klass, ext, *Array(options[:extra_exts]))
+      klass
+    end
+
+    # Unregisters an extension. This removes the both normal registrations
+    # and lazy registrations.
+    #
+    # @param extensions [Array<String>] List of extensions.
+    # @return nil
+    #
+    # @example
+    #   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
+        @template_map.delete(ext)
+        @lazy_map.delete(ext)
+      end
+
+      nil
+    end
+
     # Checks if a file extension is registered (either eagerly or
     # lazily) in this mapping.
     #
@@ -188,7 +245,7 @@ module Tilt
       lazy_map.each do |ext, choices|
         res << ext if choices.any? { |klass, file| template_class.to_s == klass }
       end
-      res
+      res.uniq
     end
 
     private
@@ -257,11 +314,6 @@ module Tilt
       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.
@@ -276,16 +328,7 @@ module Tilt
 
     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)
+        return false if scope.autoload?(n) || !scope.const_defined?(n)
         scope.const_get(n)
       end
     end

data/lib/tilt/pipeline.rb

@@ -0,0 +1,18 @@
+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/rst-pandoc.rb

@@ -1,5 +1,5 @@
 require 'tilt/template'
-require 'pandoc'
+require_relative 'pandoc'
 
 module Tilt
   # Pandoc reStructuredText implementation. See:

data/lib/tilt/sigil.rb

@@ -1,6 +1,8 @@
 require 'open3'
 require 'shellwords'
 
+warn "Tilt::SigilTemplate is deprecated"
+
 module Tilt
   # Standalone string interpolator and template processor implementation in Go.
   # see: https://github.com/gliderlabs/sigil

data/lib/tilt/template.rb

@@ -1,17 +1,11 @@
-require 'thread'
-
 module Tilt
   # @private
-  TOPOBJECT = if RUBY_VERSION >= '2.0'
-    # @private
-    module CompiledTemplates
-      self
-    end
-  elsif RUBY_VERSION >= '1.9'
-    BasicObject
-  else
-    Object
+  module CompiledTemplates
   end
+
+  # @private
+  TOPOBJECT = CompiledTemplates
+
   # @private
   LOCK = Mutex.new
 
@@ -33,6 +27,12 @@ module Tilt
     # interface.
     attr_reader :options
 
+    # A path ending in .rb that the template code will be written to, then
+    # required, instead of being evaled.  This is useful for determining
+    # coverage of compiled template code, or to use static analysis tools
+    # on the compiled template code.
+    attr_reader :compiled_path
+
     class << self
       # An empty Hash that the template engine can populate with various
       # metadata.
@@ -136,6 +136,17 @@ module Tilt
       end
     end
 
+    # Set the prefix to use for compiled paths.
+    def compiled_path=(path)
+      if path
+        # Use expanded paths when loading, since that is helpful
+        # for coverage.  Remove any .rb suffix, since that will
+        # be added back later.
+        path = File.expand_path(path.sub(/\.rb\z/i, ''))
+      end
+      @compiled_path = path
+    end
+
     protected
 
     # @!group For template implementations
@@ -144,9 +155,7 @@ module Tilt
     # default_encoding-option if present. You may override this method
     # in your template class if you have a better hint of the data's
     # encoding.
-    def default_encoding
-      @default_encoding
-    end
+    attr_reader :default_encoding
 
     # Do whatever preparation is necessary to setup the underlying template
     # engine. Called immediately after template data is loaded. Instance
@@ -158,6 +167,7 @@ module Tilt
     end
 
     CLASS_METHOD = Kernel.instance_method(:class)
+    USE_BIND_CALL = RUBY_VERSION >= '2.7'
 
     # Execute the compiled template and return the result string. Template
     # evaluation is guaranteed to be performed in the scope object with the
@@ -168,17 +178,20 @@ module Tilt
     def evaluate(scope, locals, &block)
       locals_keys = locals.keys
       locals_keys.sort!{|x, y| x.to_s <=> y.to_s}
+
       case scope
       when Object
-        method = compiled_method(locals_keys, Module === scope ? scope : scope.class)
+        scope_class = Module === scope ? scope : scope.class
       else
-        if RUBY_VERSION >= '2'
-          method = compiled_method(locals_keys, CLASS_METHOD.bind(scope).call)
-        else
-          method = compiled_method(locals_keys, Object)
-        end
+        scope_class = USE_BIND_CALL ? CLASS_METHOD.bind_call(scope) : CLASS_METHOD.bind(scope).call
+      end
+      method = compiled_method(locals_keys, scope_class)
+
+      if USE_BIND_CALL
+        method.bind_call(scope, locals, &block)
+      else
+        method.bind(scope).call(locals, &block)
       end
-      method.bind(scope).call(locals, &block)
     end
 
     # Generates all template source by combining the preamble, template, and
@@ -269,18 +282,58 @@ module Tilt
         method_source.force_encoding(source.encoding)
       end
 
-      method_source << <<-RUBY
-        TOPOBJECT.class_eval do
-          def #{method_name}(locals)
-            #{local_code}
-      RUBY
+      if freeze_string_literals?
+        method_source << "# frozen-string-literal: true\n"
+      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"
+
       offset += method_source.count("\n")
       method_source << source
       method_source << "\nend;end;"
-      (scope_class || Object).class_eval(method_source, eval_file, line - offset)
+
+      bind_compiled_method(method_source, offset, scope_class, local_keys)
       unbind_compiled_method(method_name)
     end
 
+    def bind_compiled_method(method_source, offset, scope_class, local_keys)
+      path = compiled_path
+      if path && scope_class.name
+        path = path.dup
+
+        if defined?(@compiled_path_counter)
+          path << '-' << @compiled_path_counter.succ!
+        else
+          @compiled_path_counter = "0".dup
+        end
+        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"
+
+        load_compiled_method(path, method_source)
+      else
+        if path
+          warn "compiled_path (#{compiled_path.inspect}) ignored on template with anonymous scope_class (#{scope_class.inspect})"
+        end
+
+        eval_compiled_method(method_source, offset, scope_class)
+      end
+    end
+
+    def eval_compiled_method(method_source, offset, scope_class)
+      (scope_class || Object).class_eval(method_source, eval_file, line - offset)
+    end
+
+    def load_compiled_method(path, method_source)
+      File.binwrite(path, method_source)
+
+      # Use load and not require, so unbind_compiled_method does not
+      # break if the same path is used more than once.
+      load path
+    end
+
     def unbind_compiled_method(method_name)
       method = TOPOBJECT.instance_method(method_name)
       TOPOBJECT.class_eval { remove_method(method_name) }
@@ -297,6 +350,10 @@ module Tilt
       end
     end
 
+    def freeze_string_literals?
+      false
+    end
+
     def binary(string)
       original_encoding = string.encoding
       string.force_encoding(Encoding::BINARY)

data/lib/tilt.rb

@@ -1,16 +1,16 @@
-require 'tilt/mapping'
-require 'tilt/template'
+require_relative 'tilt/mapping'
+require_relative 'tilt/template'
 
 # Namespace for Tilt. This module is not intended to be included anywhere.
 module Tilt
   # Current version.
-  VERSION = '2.0.11'
+  VERSION = '2.1.0'
 
   @default_mapping = Mapping.new
 
-  # @return [Tilt::Mapping] the main mapping object
-  def self.default_mapping
-    @default_mapping
+  class << self
+    # @return [Tilt::Mapping] the main mapping object
+    attr_reader :default_mapping
   end
 
   # @private
@@ -28,6 +28,11 @@ module Tilt
     default_mapping.register_lazy(class_name, file, *extensions)
   end
 
+  # @see Tilt::Mapping#register_pipeline
+  def self.register_pipeline(ext, options={})
+    default_mapping.register_pipeline(ext, options)
+  end
+
   # @deprecated Use {register} instead.
   def self.prefer(template_class, *extensions)
     register(template_class, *extensions)
@@ -140,7 +145,7 @@ module Tilt
   register_lazy :HamlTemplate,         'tilt/haml',      'haml'
   register_lazy :LessTemplate,         'tilt/less',      'less'
   register_lazy :LiquidTemplate,       'tilt/liquid',    'liquid'
-  register_lazy :LiveScriptTemplate,   'tilt/livescript','ls'
+  register_lazy :LiveScriptTemplate,   'tilt/livescript','ls', 'livescript'
   register_lazy :MarkabyTemplate,      'tilt/markaby',   'mab'
   register_lazy :NokogiriTemplate,     'tilt/nokogiri',  'nokogiri'
   register_lazy :PlainTemplate,        'tilt/plain',     'html'
@@ -162,6 +167,5 @@ module Tilt
   register_lazy 'Tilt::HandlebarsTemplate',  'tilt/handlebars', 'handlebars', 'hbs'
   register_lazy 'Tilt::OrgTemplate',         'org-ruby',        'org'
   register_lazy 'Tilt::EmacsOrgTemplate',    'tilt/emacs_org',  'org'
-  register_lazy 'Opal::Processor',           'opal',            'opal', 'rb'
   register_lazy 'Tilt::JbuilderTemplate',    'tilt/jbuilder',   'jbuilder'
 end

metadata

@@ -1,14 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: tilt
 version: !ruby/object:Gem::Version
-  version: 2.0.11
+  version: 2.1.0
 platform: ruby
 authors:
 - Ryan Tomayko
+- Magnus Holm
+- Jeremy Evans
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-07-22 00:00:00.000000000 Z
+date: 2023-02-17 00:00:00.000000000 Z
 dependencies: []
 description: Generic interface to multiple Ruby template engines
 email: r@tomayko.com
@@ -28,7 +30,6 @@ files:
 - lib/tilt/commonmarker.rb
 - lib/tilt/creole.rb
 - lib/tilt/csv.rb
-- lib/tilt/dummy.rb
 - lib/tilt/erb.rb
 - lib/tilt/erubi.rb
 - lib/tilt/erubis.rb
@@ -43,6 +44,7 @@ files:
 - lib/tilt/maruku.rb
 - lib/tilt/nokogiri.rb
 - lib/tilt/pandoc.rb
+- lib/tilt/pipeline.rb
 - lib/tilt/plain.rb
 - lib/tilt/prawn.rb
 - lib/tilt/radius.rb
@@ -58,10 +60,14 @@ files:
 - lib/tilt/typescript.rb
 - lib/tilt/wikicloth.rb
 - lib/tilt/yajl.rb
-homepage: https://github.com/rtomayko/tilt/
+homepage: https://github.com/jeremyevans/tilt
 licenses:
 - MIT
-metadata: {}
+metadata:
+  bug_tracker_uri: https://github.com/jeremyevans/tilt/issues
+  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"
@@ -76,15 +82,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.29
+rubygems_version: 3.4.6
 signing_key:
-specification_version: 2
+specification_version: 4
 summary: Generic interface to multiple Ruby template engines
 test_files: []

data/lib/tilt/dummy.rb

@@ -1,3 +0,0 @@
-# Used for detecting autoloading bug in JRuby
-class Tilt::Dummy; end
-