brakeman 7.1.2 → 8.0.0

data/bundle/ruby/3.2.0/gems/erubi-1.13.1/lib/erubi.rb

@@ -0,0 +1,299 @@
+# frozen_string_literal: true
+
+module Erubi
+  VERSION = '1.13.1'
+
+  # :nocov:
+  if RUBY_VERSION >= '1.9'
+    RANGE_FIRST = 0
+    RANGE_LAST = -1
+  else
+    RANGE_FIRST = 0..0
+    RANGE_LAST = -1..-1
+  end
+
+  MATCH_METHOD = RUBY_VERSION >= '2.4' ? :match? : :match
+  SKIP_DEFINED_FOR_INSTANCE_VARIABLE = RUBY_VERSION > '3'
+  FREEZE_TEMPLATE_LITERALS = !eval("''").frozen? && RUBY_VERSION >= '2.1'
+  # :nocov:
+
+  begin
+    require 'erb/escape'
+    define_method(:h, ERB::Escape.instance_method(:html_escape))
+  # :nocov:
+  rescue LoadError
+    begin
+      require 'cgi/escape'
+      unless CGI.respond_to?(:escapeHTML) # work around for JRuby 9.1
+        CGI = Object.new
+        CGI.extend(defined?(::CGI::Escape) ? ::CGI::Escape : ::CGI::Util)
+      end
+      # Escape characters with their HTML/XML equivalents.
+      def h(value)
+        CGI.escapeHTML(value.to_s)
+      end
+    rescue LoadError
+      ESCAPE_TABLE = {'&' => '&amp;'.freeze, '<' => '&lt;'.freeze, '>' => '&gt;'.freeze, '"' => '&quot;'.freeze, "'" => '&#39;'.freeze}.freeze
+      if RUBY_VERSION >= '1.9'
+        def h(value)
+          value.to_s.gsub(/[&<>"']/, ESCAPE_TABLE)
+        end
+      else
+        def h(value)
+          value.to_s.gsub(/[&<>"']/){|s| ESCAPE_TABLE[s]}
+        end
+      end
+    end
+  end
+  # :nocov:
+  module_function :h
+
+  class Engine
+    # The default regular expression used for scanning.
+    DEFAULT_REGEXP = /<%(={1,2}|-|\#|%)?(.*?)([-=])?%>([ \t]*\r?\n)?/m
+    
+    # The frozen ruby source code generated from the template, which can be evaled.
+    attr_reader :src
+
+    # The filename of the template, if one was given.
+    attr_reader :filename
+
+    # The variable name used for the buffer variable.
+    attr_reader :bufvar
+
+    # Initialize a new Erubi::Engine.  Options:
+    # +:bufval+ :: The value to use for the buffer variable, as a string (default <tt>'::String.new'</tt>).
+    # +:bufvar+ :: The variable name to use for the buffer variable, as a string.
+    # +:chain_appends+ :: Whether to chain <tt><<</t> calls to the buffer variable. Offers better
+    #                     performance, but can cause issues when the buffer variable is reassigned during
+    #                     template rendering (default +false+).
+    # +:ensure+ :: Wrap the template in a begin/ensure block restoring the previous value of bufvar.
+    # +:escapefunc+ :: The function to use for escaping, as a string (default: <tt>'::Erubi.h'</tt>).
+    # +:escape+ :: Whether to make <tt><%=</tt> escape by default, and <tt><%==</tt> not escape by default.
+    # +:escape_html+ :: Same as +:escape+, with lower priority.
+    # +:filename+ :: The filename for the template.
+    # +:freeze+ :: Whether to enable add a <tt>frozen_string_literal: true</tt> magic comment at the top of
+    #              the resulting source code.  Note this may cause problems if you are wrapping the resulting
+    #              source code in other code, because the magic comment only has an effect at the beginning of
+    #              the file, and having the magic comment later in the file can trigger warnings.
+    # +:freeze_template_literals+ :: Whether to suffix all literal strings for template code with <tt>.freeze</tt>
+    #                                (default: +true+ on Ruby 2.1+, +false+ on Ruby 2.0 and older).
+    #                                Can be set to +false+ on Ruby 2.3+ when frozen string literals are enabled
+    #                                in order to improve performance.
+    # +:literal_prefix+ :: The prefix to output when using escaped tag delimiters (default <tt>'<%'</tt>).
+    # +:literal_postfix+ :: The postfix to output when using escaped tag delimiters (default <tt>'%>'</tt>).
+    # +:outvar+ :: Same as +:bufvar+, with lower priority.
+    # +:postamble+ :: The postamble for the template, by default returns the resulting source code.
+    # +:preamble+ :: The preamble for the template, by default initializes the buffer variable.
+    # +:regexp+ :: The regexp to use for scanning.
+    # +:src+ :: The initial value to use for the source code, an empty string by default.
+    # +:trim+ :: Whether to trim leading and trailing whitespace, true by default.
+    def initialize(input, properties={})
+      @escape = escape = properties.fetch(:escape){properties.fetch(:escape_html, false)}
+      trim       = properties[:trim] != false
+      @filename  = properties[:filename]
+      @bufvar = bufvar = properties[:bufvar] || properties[:outvar] || "_buf"
+      bufval = properties[:bufval] || '::String.new'
+      regexp = properties[:regexp] || DEFAULT_REGEXP
+      literal_prefix = properties[:literal_prefix] || '<%'
+      literal_postfix = properties[:literal_postfix] || '%>'
+      preamble   = properties[:preamble] || "#{bufvar} = #{bufval};"
+      postamble  = properties[:postamble] || "#{bufvar}.to_s\n"
+      @chain_appends = properties[:chain_appends]
+      @text_end = if properties.fetch(:freeze_template_literals, FREEZE_TEMPLATE_LITERALS)
+        "'.freeze"
+      else
+        "'"
+      end
+
+      @buffer_on_stack = false
+      @src = src = properties[:src] || String.new
+      src << "# frozen_string_literal: true\n" if properties[:freeze]
+      if properties[:ensure]
+        src << "begin; __original_outvar = #{bufvar}"
+        if SKIP_DEFINED_FOR_INSTANCE_VARIABLE && /\A@[^@]/ =~ bufvar
+          src << "; "
+        else
+          src << " if defined?(#{bufvar}); "
+        end
+      end
+
+      unless @escapefunc = properties[:escapefunc]
+        if escape
+          @escapefunc = '__erubi.h'
+          src << "__erubi = ::Erubi; "
+        else
+          @escapefunc = '::Erubi.h'
+        end
+      end
+
+      src << preamble
+
+      pos = 0
+      is_bol = true
+      input.scan(regexp) do |indicator, code, tailch, rspace|
+        match = Regexp.last_match
+        len  = match.begin(0) - pos
+        text = input[pos, len]
+        pos  = match.end(0)
+        ch   = indicator ? indicator[RANGE_FIRST] : nil
+
+        lspace = nil
+
+        unless ch == '='
+          if text.empty?
+            lspace = "" if is_bol
+          elsif text[RANGE_LAST] == "\n"
+            lspace = ""
+          else
+            rindex = text.rindex("\n")
+            if rindex
+              range = rindex+1..-1
+              s = text[range]
+              if /\A[ \t]*\z/.send(MATCH_METHOD, s)
+                lspace = s
+                text[range] = ''
+              end
+            else
+              if is_bol && /\A[ \t]*\z/.send(MATCH_METHOD, text)
+                lspace = text
+                text = ''
+              end
+            end
+          end
+        end
+
+        is_bol = rspace
+        add_text(text)
+        case ch
+        when '='
+          rspace = nil if tailch && !tailch.empty?
+          add_expression(indicator, code)
+          add_text(rspace) if rspace
+        when nil, '-'
+          if trim && lspace && rspace
+            add_code("#{lspace}#{code}#{rspace}")
+          else
+            add_text(lspace) if lspace
+            add_code(code)
+            add_text(rspace) if rspace
+          end
+        when '#'
+          n = code.count("\n") + (rspace ? 1 : 0)
+          if trim && lspace && rspace
+            add_code("\n" * n)
+          else
+            add_text(lspace) if lspace
+            add_code("\n" * n)
+            add_text(rspace) if rspace
+          end
+        when '%'
+          add_text("#{lspace}#{literal_prefix}#{code}#{tailch}#{literal_postfix}#{rspace}")
+        else
+          handle(indicator, code, tailch, rspace, lspace)
+        end
+      end
+      rest = pos == 0 ? input : input[pos..-1]
+      add_text(rest)
+
+      src << "\n" unless src[RANGE_LAST] == "\n"
+      add_postamble(postamble)
+      src << "; ensure\n  " << bufvar << " = __original_outvar\nend\n" if properties[:ensure]
+      src.freeze
+      freeze
+    end
+
+    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:
+
+    # Add raw text to the template.  Modifies argument if argument is mutable as a memory optimization.
+    # Must be called with a string, cannot be called with nil (Rails's subclass depends on it).
+    def add_text(text)
+      return if text.empty?
+
+      text = _dup_string_if_frozen(text)
+      text.gsub!(/['\\]/, '\\\\\&')
+
+      with_buffer{@src << " << '" << text << @text_end}
+    end
+
+    # Add ruby code to the template
+    def add_code(code)
+      terminate_expression
+      @src << code
+      @src << ';' unless code[RANGE_LAST] == "\n"
+      @buffer_on_stack = false
+    end
+
+    # Add the given ruby expression result to the template,
+    # escaping it based on the indicator given and escape flag.
+    def add_expression(indicator, code)
+      if ((indicator == '=') ^ @escape)
+        add_expression_result(code)
+      else
+        add_expression_result_escaped(code)
+      end
+    end
+
+    # Add the result of Ruby expression to the template
+    def add_expression_result(code)
+      with_buffer{@src << ' << (' << code << ').to_s'}
+    end
+
+    # Add the escaped result of Ruby expression to the template
+    def add_expression_result_escaped(code)
+      with_buffer{@src << ' << ' << @escapefunc << '((' << code << '))'}
+    end
+
+    # Add the given postamble to the src.  Can be overridden in subclasses
+    # to make additional changes to src that depend on the current state.
+    def add_postamble(postamble)
+      terminate_expression
+      @src << postamble
+    end
+
+    # Raise an exception, as the base engine class does not support handling other indicators.
+    def handle(indicator, code, tailch, rspace, lspace)
+      raise ArgumentError, "Invalid indicator: #{indicator}"
+    end
+
+    # Make sure the buffer variable is the target of the next append
+    # before yielding to the block. Mark that the buffer is the target
+    # of the next append after the block executes.
+    #
+    # This method should only be called if the block will result in
+    # code where << will append to the bufvar.
+    def with_buffer
+      if @chain_appends
+        unless @buffer_on_stack
+          @src << '; ' << @bufvar
+        end
+        yield
+        @buffer_on_stack = true
+      else
+        @src << ' ' << @bufvar
+        yield
+        @src << ';'
+      end
+    end
+
+    # Make sure that any current expression has been terminated.
+    # The default is to terminate all expressions, but when
+    # the chain_appends option is used, expressions may not be
+    # terminated.
+    def terminate_expression
+      @src << '; ' if @chain_appends
+    end
+  end
+end

data/bundle/ruby/3.2.0/gems/{tilt-2.6.1 → tilt-2.7.0}/lib/tilt/asciidoc.rb

@@ -1,14 +1,21 @@
 # frozen_string_literal: true
-require_relative 'template'
-require 'asciidoctor'
-# AsciiDoc see: http://asciidoc.org/
 
-# Asciidoctor implementation for AsciiDoc see:
-# http://asciidoctor.github.com/
+# = AsciiDoc
+#
+# Asciidoctor implementation for AsciiDoc
 #
 # Asciidoctor is an open source, pure-Ruby processor for
 # converting AsciiDoc documents or strings into HTML 5,
 # DocBook 4.5 and other formats.
+#
+# === See also
+#
+# * http://asciidoc.org
+# * http://asciidoctor.github.com
+
+require_relative 'template'
+require 'asciidoctor'
+
 Tilt::AsciidoctorTemplate = Tilt::StaticTemplate.subclass do
   @options[:header_footer] = false if @options[:header_footer].nil?
   Asciidoctor.render(@data, @options)

data/bundle/ruby/3.2.0/gems/{tilt-2.6.1 → tilt-2.7.0}/lib/tilt/babel.rb

@@ -1,4 +1,9 @@
 # frozen_string_literal: true
+
+# = Babel
+#
+#
+
 require_relative 'template'
 require 'babel/transpiler'
 

data/bundle/ruby/3.2.0/gems/{tilt-2.6.1 → tilt-2.7.0}/lib/tilt/builder.rb

@@ -1,4 +1,8 @@
 # frozen_string_literal: true
+
+# = Builder
+#
+
 require_relative 'template'
 require 'builder'
 

data/bundle/ruby/3.2.0/gems/{tilt-2.6.1 → tilt-2.7.0}/lib/tilt/coffee.rb

@@ -1,12 +1,22 @@
 # frozen_string_literal: true
+
+# CoffeeScript / Literate CoffeeScript template implementation.
+#
+# CoffeeScript templates do not support object scopes, locals, or yield.
+#
+# === See also
+#
+# * http://coffeescript.org
+#
+# === Related modules
+#
+# * Tilt::CoffeeScriptTemplate
+# * Tilt::CoffeeScriptLiterateTemplate
+
 require_relative 'template'
 require 'coffee_script'
 
 module Tilt
-  # CoffeeScript template implementation. See:
-  # http://coffeescript.org/
-  #
-  # CoffeeScript templates do not support object scopes, locals, or yield.
   class CoffeeScriptTemplate < StaticTemplate
     self.default_mime_type = 'application/javascript'
 

data/bundle/ruby/3.2.0/gems/{tilt-2.6.1 → tilt-2.7.0}/lib/tilt/commonmarker.rb

@@ -1,4 +1,45 @@
 # frozen_string_literal: true
+#
+# = Markdown (<tt>markdown</tt>, <tt>md</tt>, <tt>mkd</tt>)
+#
+# Markdown is a lightweight markup language, created by John Gruber
+# and Aaron Swartz. For any markup that is not covered by Markdown’s syntax, HTML
+# is used.  Marking up plain text with Markdown markup is easy and Markdown
+# formatted texts are readable.
+#
+# === Example
+#
+#     Hello Markdown Templates
+#     ========================
+#
+#     Hello World. This is a paragraph.
+#
+# === Usage
+#
+# To wrap a Markdown formatted document with a layout:
+#
+#     layout = Tilt['erb'].new do
+#       "<!doctype html><title></title><%= yield %>"
+#     end
+#     data = Tilt['md'].new { "# hello tilt" }
+#     layout.render { data.render }
+#     # => "<!doctype html><title></title><h1>hello tilt</h1>\n"
+#
+# === Options
+#
+# ==== <tt>:smartypants => true|false</tt>
+#
+# Set <tt>true</tt> to enable [Smarty Pants][smartypants] style punctuation replacement.
+#
+# ==== <tt>:escape_html => true|false</tt>
+#
+# Set <tt>true</tt> disallow raw HTML in Markdown contents. HTML is converted to
+# literal text by escaping <tt><</tt> characters.
+#
+# === See also
+#
+# * {Markdown Syntax Documentation}[http://daringfireball.net/projects/markdown/syntax]
+
 require_relative 'template'
 require 'commonmarker'
 

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+# = CSV
+#
+# CSV Template implementation.
+#
+# === Example
+#
+#    # Example of csv template
+#    tpl = <<-EOS
+#      # header
+#      csv << ['NAME', 'ID']
+#
+#      # data rows
+#      @people.each do |person|
+#        csv << [person[:name], person[:id]]
+#      end
+#    EOS
+#
+#    @people = [
+#      {:name => "Joshua Peek", :id => 1},
+#      {:name => "Ryan Tomayko", :id => 2},
+#      {:name => "Simone Carletti", :id => 3}
+#    ]
+#
+#    template = Tilt::CSVTemplate.new { tpl }
+#    template.render(self)
+#
+# === See also
+#
+# * http://ruby-doc.org/stdlib/libdoc/csv/rdoc/CSV.html
+#
+# === Related module
+#
+# * Tilt::CSVTemplate
+
+require_relative 'template'
+require 'csv'
+
+module Tilt
+
+  class CSVTemplate < Template
+    self.default_mime_type = 'text/csv'
+
+    def prepare
+      @outvar = @options.delete(:outvar) || '_csvout'
+    end
+
+    def precompiled_template(locals)
+      <<-RUBY
+        #{@outvar} = CSV.generate(**#{@options}) do |csv|
+          #{@data}
+        end
+      RUBY
+    end
+
+    def precompiled(locals)
+      source, offset = super
+      [source, offset + 1]
+    end
+
+  end
+end

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

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+# = ERB (<tt>erb</tt>, <tt>rhtml</tt>)
+#
+# ERB is a simple but powerful template languge for Ruby. In Tilt it's
+# backed by {Erubi}[rdoc-ref:lib/tilt/erubi.rb] (if installed on your system] or by
+# {erb.rb}[rdoc-ref:lib/tilt/erb.rb] (which is included in Ruby's standard library]. This
+# documentation applies to both implementations.
+#
+# === Example
+#
+#     Hello <%= world %>!
+#
+# === Usage
+#
+# ERB templates support custom evaluation scopes and locals:
+#
+#     >> require 'erb'
+#     >> template = Tilt.new('hello.html.erb')
+#     >> template.render(self, :world => 'World!')
+#     => "Hello World!"
+#
+# Or, use <tt>Tilt['erb']</tt> directly to process strings:
+#
+#     template = Tilt['erb'].new { "Hello <%= world %>!" }
+#     template.render(self, :world => 'World!')
+#
+# The <tt>Tilt::ERBTemplate</tt> class is registered for all files ending in <tt>.erb</tt> or
+# <tt>.rhtml</tt> by default, but with a *lower* priority than ErubiTemplate.
+# If you specifically want to use ERB, it's recommended to use
+# <tt>#prefer</tt>:
+#
+#     Tilt.prefer Tilt::ERBTemplate
+#
+# __NOTE:__ It's suggested that your program <tt>require 'erb'</tt> at load time when
+# using this template engine within a threaded environment.
+#
+# === Options
+#
+# ==== <tt>:trim => trim</tt>
+#
+# The ERB trim mode flags. This is a string consisting of any combination of the
+# following characters:
+#
+# * <tt>'>'</tt>  omits newlines for lines ending in <tt>></tt>
+# * <tt>'<>'</tt> omits newlines for lines starting with <tt><%</tt> and ending in <tt>%></tt>
+# * <tt>'%'</tt>  enables processing of lines beginning with <tt>%</tt>
+# * <tt>true</tt> is an alias of <tt><></tt>
+#
+# ==== <tt>:outvar => '_erbout'</tt>
+#
+# The name of the variable used to accumulate template output. This can be
+# any valid Ruby expression but must be assignable. By default a local
+# variable named <tt>_erbout</tt> is used.
+#
+# ==== <tt>:freeze => false</tt>
+#
+# If set to true, will set the <tt>frozen_string_literal</tt> flag in the compiled
+# template code, so that string literals inside the templates will be frozen.
+#
+# === See also
+#
+# * http://www.ruby-doc.org/stdlib/libdoc/erb/rdoc/classes/ERB.html
+#
+# === Related module
+#
+# * Tilt::ERBTemplate
+
+require_relative 'template'
+require 'erb'
+
+module Tilt
+  class ERBTemplate < Template
+    SUPPORTS_KVARGS = ::ERB.instance_method(:initialize).parameters.assoc(:key) rescue false
+
+    def prepare
+      @freeze_string_literals = !!@options[:freeze]
+      @outvar = @options[:outvar] || '_erbout'
+      trim = case @options[:trim]
+      when false
+        nil
+      when nil, true
+        '<>'
+      else
+        @options[:trim]
+      end
+      @engine = if SUPPORTS_KVARGS
+        ::ERB.new(@data, trim_mode: trim, eoutvar: @outvar)
+      # :nocov:
+      else
+        ::ERB.new(@data, options[:safe], trim, @outvar)
+      # :nocov:
+      end
+    end
+
+    def precompiled_template(locals)
+      source = @engine.src
+      source
+    end
+
+    def precompiled_preamble(locals)
+      <<-RUBY
+        begin
+          __original_outvar = #{@outvar} if defined?(#{@outvar})
+          #{super}
+      RUBY
+    end
+
+    def precompiled_postamble(locals)
+      <<-RUBY
+          #{super}
+        ensure
+          #{@outvar} = __original_outvar
+        end
+      RUBY
+    end
+
+    # ERB generates a line to specify the character coding of the generated
+    # source in 1.9. Account for this in the line offset.
+    def precompiled(locals)
+      source, offset = super
+      [source, offset + 1]
+    end
+
+    def freeze_string_literals?
+      @freeze_string_literals
+    end
+  end
+end
+

data/bundle/ruby/3.2.0/gems/{tilt-2.6.1 → tilt-2.7.0}/lib/tilt/erubi.rb

@@ -1,16 +1,49 @@
 # frozen_string_literal: true
+
+# = Erubi (<tt>erb</tt>, <tt>rhtml</tt>, <tt>erubi</tt>)
+#
+# {Erubi}[https://github.com/jeremyevans/erubi] is an ERB implementation that uses the same algorithm as
+# the erubis gem, but is maintained and offers numerous improvements.
+#
+# All the documentation of {ERB}[rdoc-ref:lib/tilt/erb.rb] applies in addition to the following:
+#
+# === Usage
+#
+# The <tt>Tilt::ErubiTemplate</tt> class is registered for all files ending in <tt>.erb</tt> or
+# <tt>.rhtml</tt> by default, with the *highest* priority.
+#
+# __NOTE:__ It's suggested that your program <tt>require 'erubi'</tt> at load time when
+# using this template engine within a threaded environment.
+#
+# === Options
+#
+# ==== <tt>:engine_class => Erubi::Engine</tt>
+#
+# Allows you to specify a custom engine class to use instead of the
+# default which is <tt>Erubi::Engine</tt>.
+#
+# ==== Other
+#
+# Other options are passed to the constructor of the engine class.
+#
+# ErubiTemplate supports the following additional options, in addition
+# to the options supported by the Erubi engine:
+#
+# :engine_class :: allows you to specify a custom engine class to use
+#                  instead of the default (which is ::Erubi::Engine).
+#
+# === See also
+#
+# * {Erubi Home}[https://github.com/jeremyevans/erubi]
+#
+# === Related module
+#
+# * Tilt::ErubiTemplate
+
 require_relative 'template'
 require 'erubi'
 
 module Tilt
-  # Erubi (a simplified version of Erubis) template implementation.
-  # See https://github.com/jeremyevans/erubi
-  #
-  # ErubiTemplate supports the following additional options, in addition
-  # to the options supported by the Erubi engine:
-  #
-  # :engine_class :: allows you to specify a custom engine class to use
-  #                  instead of the default (which is ::Erubi::Engine).
   class ErubiTemplate < Template
     def prepare
       @options[:preamble] = false

data/bundle/ruby/3.2.0/gems/{tilt-2.6.1 → tilt-2.7.0}/lib/tilt/etanni.rb

@@ -1,4 +1,11 @@
 # frozen_string_literal: true
+
+# = Etanni
+#
+# === Related module
+#
+# * Tilt::EtanniTemplate
+
 require_relative 'template'
 
 module Tilt