brakeman 6.1.2 → 6.2.0

data/bundle/ruby/3.1.0/gems/tilt-2.4.0/lib/tilt/haml.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+require_relative 'template'
+require 'haml'
+
+module Tilt
+  # Haml template implementation. See:
+  # http://haml.hamptoncatlin.com/
+  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[:filename] = eval_file
+          @options[:line] = @line
+          if @options.include?(:outvar)
+            @options[:buffer] = @options.delete(:outvar)
+            @options[:save_buffer] = true
+          end
+          @engine = ::Haml::TempleEngine.new(@options)
+          @engine.compile(@data)
+        end
+
+        def evaluate(scope, locals, &block)
+          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[:filename] = eval_file
+          @options[: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?
+
+          if @engine.respond_to?(:precompiled_method_return_value, true)
+            super
+          else
+            @engine.render(scope, locals, &block)
+          end
+        end
+
+        # Precompiled Haml source. Taken from the precompiled_with_ambles
+        # method in Haml::Precompiler:
+        # http://github.com/nex3/haml/blob/master/lib/haml/precompiler.rb#L111-126
+        def precompiled_template(locals)
+          @engine.precompiled
+        end
+
+        def precompiled_preamble(locals)
+          local_assigns = super
+          @engine.instance_eval do
+            <<-RUBY
+              begin
+                extend Haml::Helpers
+                _hamlout = @haml_buffer = Haml::Buffer.new(haml_buffer, #{options_for_buffer.inspect})
+                _erbout = _hamlout.buffer
+                __in_erb_template = true
+                _haml_locals = locals
+                #{local_assigns}
+            RUBY
+          end
+        end
+
+        def precompiled_postamble(locals)
+          @engine.instance_eval do
+            <<-RUBY
+                #{precompiled_method_return_value}
+              ensure
+                @haml_buffer = @haml_buffer.upper if haml_buffer
+              end
+            RUBY
+          end
+        end
+      end
+    end
+  end
+end

data/bundle/ruby/3.1.0/gems/tilt-2.4.0/lib/tilt/kramdown.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+require_relative 'template'
+require 'kramdown'
+
+dumb_quotes = [39, 39, 34, 34].freeze
+
+# Kramdown Markdown implementation. See: https://kramdown.gettalong.org/
+Tilt::KramdownTemplate = Tilt::StaticTemplate.subclass do
+  # dup as Krawmdown modifies the passed option with map!
+  @options[:smart_quotes] = dumb_quotes.dup unless @options[:smartypants]
+
+  Kramdown::Document.new(@data, @options).to_html
+end

data/bundle/ruby/{3.3.0/gems/tilt-2.0.11 → 3.1.0/gems/tilt-2.4.0}/lib/tilt/liquid.rb

@@ -1,11 +1,12 @@
-require 'tilt/template'
+# frozen_string_literal: true
+require_relative 'template'
 require 'liquid'
 
 module Tilt
   # Liquid template implementation. See:
   # http://liquidmarkup.org/
   #
-  # Liquid is designed to be a *safe* template system and threfore
+  # Liquid is designed to be a *safe* template system and therefore
   # does not provide direct access to execuatable scopes. In order to
   # support a +scope+, the +scope+ must be able to represent itself
   # as a hash by responding to #to_h. If the +scope+ does not respond
@@ -17,16 +18,17 @@ module Tilt
   # time when using this template engine.
   class LiquidTemplate < Template
     def prepare
-      @engine = ::Liquid::Template.parse(data, liquid_options)
+      @options[:line_numbers] = true unless @options.has_key?(:line_numbers)
+      @engine = ::Liquid::Template.parse(@data, @options)
     end
 
-    def evaluate(scope, locals, &block)
-      locals = locals.inject({}){ |h,(k,v)| h[k.to_s] = v ; h }
+    def evaluate(scope, locs)
+      locals = {}
       if scope.respond_to?(:to_h)
-        scope  = scope.to_h.inject({}){ |h,(k,v)| h[k.to_s] = v ; h }
-        locals = scope.merge(locals)
+        scope.to_h.each{|k, v| locals[k.to_s] = v}
       end
-      locals['yield'] = block.nil? ? '' : yield
+      locs.each{|k, v| locals[k.to_s] = v}
+      locals['yield'] = block_given? ? yield : ''
       locals['content'] = locals['yield']
       @engine.render(locals)
     end
@@ -34,11 +36,5 @@ module Tilt
     def allows_script?
       false
     end
-
-    private
-
-    def liquid_options
-      { line_numbers: true }.merge options
-    end
   end
 end

data/bundle/ruby/3.1.0/gems/tilt-2.4.0/lib/tilt/livescript.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+require_relative 'template'
+require 'livescript'
+
+# LiveScript template implementation. See:
+# http://livescript.net/
+#
+# LiveScript templates do not support object scopes, locals, or yield.
+Tilt::LiveScriptTemplate = Tilt::StaticTemplate.subclass(mime_type: 'application/javascript') do
+  LiveScript.compile(@data, @options)
+end

data/bundle/ruby/{3.3.0/gems/tilt-2.0.11 → 3.1.0/gems/tilt-2.4.0}/lib/tilt/mapping.rb

@@ -1,6 +1,81 @@
-require 'monitor'
+# 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
@@ -38,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
 
@@ -58,8 +135,26 @@ 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
 
     # Registers a lazy template implementation by file extension. You
@@ -85,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
 
@@ -108,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)
-      _, 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
 
@@ -195,45 +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
 
-    LOCK = Monitor.new
-
-    def lazy_load(pattern)
-      return unless @lazy_map.has_key?(pattern)
-
-      LOCK.enter
-      entered = true
-
-      choices = @lazy_map[pattern]
-
-      # Check if a template class is already present
-      choices.each do |class_name, file|
+    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
 
@@ -252,16 +342,9 @@ module Tilt
         end
       end
 
-      raise first_failure if first_failure
-    ensure
-      LOCK.exit if entered
+      raise first_failure
     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,18 +359,54 @@ 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
   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/bundle/ruby/{3.3.0/gems/tilt-2.0.11 → 3.1.0/gems/tilt-2.4.0}/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/bundle/ruby/3.1.0/gems/tilt-2.4.0/lib/tilt/maruku.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+require_relative 'template'
+require 'maruku'
+
+warn 'tilt/maruku is deprecated, as maruku requires modifying string literals', uplevel: 1
+
+# Maruku markdown implementation. See: https://github.com/bhollis/maruku
+Tilt::MarukuTemplate = Tilt::StaticTemplate.subclass do
+  Maruku.new(@data, @options).to_html
+end

data/bundle/ruby/{3.3.0/gems/tilt-2.0.11 → 3.1.0/gems/tilt-2.4.0}/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
-