brakeman 6.2.2 → 8.0.4

data/bundle/ruby/{3.1.0/gems/tilt-2.4.0 → 3.2.0/gems/tilt-2.7.0}/lib/tilt/template.rb

@@ -41,12 +41,12 @@ module Tilt
         @metadata ||= {}
       end
 
-      # Use `.metadata[:mime_type]` instead.
+      # Use <tt>.metadata[:mime_type]</tt> instead.
       def default_mime_type
         metadata[:mime_type]
       end
 
-      # Use `.metadata[:mime_type] = val` instead.
+      # Use <tt>.metadata[:mime_type] = val</tt> instead.
       def default_mime_type=(value)
         metadata[:mime_type] = value
       end
@@ -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,7 +122,9 @@ 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
@@ -119,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
@@ -129,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
@@ -145,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
@@ -181,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
@@ -190,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
@@ -267,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
@@ -291,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)
@@ -305,19 +376,49 @@ module Tilt
 
       s = "locals = locals[:locals]"
       if assignments.delete(s)
-        # If there is a locals key itself named `locals`, delete it from the ordered keys so we can
+        # If there is a locals key itself named <tt>locals</tt>, delete it from the ordered keys so we can
         # assign it last. This is important because the assignment of all other locals depends on the
-        # `locals` local variable still matching the `locals` method argument given to the method
-        # created in `#compile_template_method`.
+        # <tt>locals</tt> local variable still matching the <tt>locals</tt> method argument given to the method
+        # created in <tt>#compile_template_method</tt>.
         assignments << s
       end
 
       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
@@ -328,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
@@ -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/bundle/ruby/{3.1.0/gems/tilt-2.4.0 → 3.2.0/gems/tilt-2.7.0}/lib/tilt/typescript.rb

@@ -1,4 +1,9 @@
 # frozen_string_literal: true
+
+# = Typescript
+#
+# TypeScript implementation.
+
 require_relative 'template'
 require 'typescript-node'
 

data/bundle/ruby/3.2.0/gems/tilt-2.7.0/lib/tilt/yajl.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+# = Yajl
+#
+# Yajl Template implementation
+#
+# Yajl is a fast JSON parsing and encoding library for Ruby
+#
+# The template source is evaluated as a Ruby string,
+# and the result is converted #to_json.
+#
+# === Example
+#
+#    # This is a template example.
+#    # The template can contain any Ruby statement.
+#    tpl <<-EOS
+#      @counter = 0
+#
+#      # The json variable represents the buffer
+#      # and holds the data to be serialized into json.
+#      # It defaults to an empty hash, but you can override it at any time.
+#      json = {
+#        :"user#{@counter += 1}" => { :name => "Joshua Peek", :id => @counter },
+#        :"user#{@counter += 1}" => { :name => "Ryan Tomayko", :id => @counter },
+#        :"user#{@counter += 1}" => { :name => "Simone Carletti", :id => @counter },
+#      }
+#
+#      # Since the json variable is a Hash,
+#      # you can use conditional statements or any other Ruby statement
+#      # to populate it.
+#      json[:"user#{@counter += 1}"] = { :name => "Unknown" } if 1 == 2
+#
+#      # The last line doesn't affect the returned value.
+#      nil
+#    EOS
+#
+#    template = Tilt::YajlTemplate.new { tpl }
+#    template.render(self)
+#
+# === See also
+#
+# * https://github.com/brianmario/yajl-ruby
+#
+# === Related module
+#
+# * Tilt::YajlTemplate
+
+require_relative 'template'
+require 'yajl'
+
+module Tilt
+  class YajlTemplate < Template
+    self.default_mime_type = 'application/json'
+
+    def evaluate(scope, locals, &block)
+      decorate(super)
+    end
+
+    def precompiled_preamble(locals)
+      return super if locals.include? :json
+      "json = {}\n#{super}"
+    end
+
+    def precompiled_postamble(locals)
+      "Yajl::Encoder.new.encode(json)"
+    end
+
+    def precompiled_template(locals)
+      @data.to_str
+    end
+
+    # Decorates the +json+ input according to given +options+.
+    #
+    # json    - The json String to decorate.
+    # options - The option Hash to customize the behavior.
+    #
+    # Returns the decorated String.
+    def decorate(json)
+      callback, variable = @options[:callback], @options[:variable]
+      if callback && variable
+        "var #{variable} = #{json}; #{callback}(#{variable});"
+      elsif variable
+        "var #{variable} = #{json};"
+      elsif callback
+        "#{callback}(#{json});"
+      else
+        json
+      end
+    end
+  end
+end

data/bundle/ruby/{3.1.0/gems/tilt-2.4.0 → 3.2.0/gems/tilt-2.7.0}/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.4.0'
+  VERSION = '2.7.0'
+
+  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
@@ -86,6 +90,10 @@ module Tilt
     # @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
@@ -139,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'
@@ -157,7 +163,6 @@ module Tilt
   register_lazy :CSVTemplate,          'tilt/csv',       'rcsv'
   register_lazy :CoffeeScriptTemplate, 'tilt/coffee',    'coffee'
   register_lazy :CoffeeScriptLiterateTemplate, 'tilt/coffee', 'litcoffee'
-  register_lazy :CreoleTemplate,       'tilt/creole',    'wiki', 'creole'
   register_lazy :EtanniTemplate,       'tilt/etanni',    'etn', 'etanni'
   register_lazy :HamlTemplate,         'tilt/haml',      'haml'
   register_lazy :LiquidTemplate,       'tilt/liquid',    'liquid'
@@ -175,7 +180,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