brakeman 6.2.2 → 8.0.6

data/bundle/ruby/{3.1.0/gems/tilt-2.4.0 → 3.2.0/gems/tilt-2.8.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'
 
@@ -9,14 +50,24 @@ if defined?(::Commonmarker)
   parse_opts = [
     :smart,
     :default_info_string,
+    :relaxed_tasklist_matching,
+    :relaxed_autolinks,
+    :leave_footnote_definitions,
+    :ignore_setext,
   ].freeze
   render_opts = [
     :hardbreaks,
     :github_pre_lang,
+    :full_info_string,
     :width,
     :unsafe,
     :escape,
     :sourcepos,
+    :escaped_char_spans,
+    :ignore_empty_links,
+    :gfm_quirks,
+    :prefer_fenced,
+    :tasklist_classes,
   ].freeze
   exts = [
     :strikethrough,
@@ -27,9 +78,23 @@ if defined?(::Commonmarker)
     :superscript,
     :header_ids,
     :footnotes,
+    :inline_footnotes,
     :description_lists,
     :front_matter_delimiter,
+    :multiline_block_quotes,
+    :math_dollars,
+    :math_code,
     :shortcodes,
+    :wikilinks_title_before_pipe,
+    :wikilinks_title_after_pipe,
+    :underline,
+    :spoiler,
+    :greentext,
+    :subscript,
+    :subtext,
+    :alerts,
+    :cjk_friendly_emphasis,
+    :highlight,
   ].freeze
 
   Tilt::CommonMarkerTemplate = Tilt::StaticTemplate.subclass do

data/bundle/ruby/3.2.0/gems/tilt-2.8.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.8.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.1.0/gems/tilt-2.4.0 → 3.2.0/gems/tilt-2.8.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.1.0/gems/tilt-2.4.0 → 3.2.0/gems/tilt-2.8.0}/lib/tilt/etanni.rb

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

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

@@ -1,4 +1,70 @@
 # frozen_string_literal: true
+
+# = Haml (<tt>haml</tt>)
+#
+# {Haml}[https://haml.info] is a markup language that’s used to cleanly and simply describe
+# the HTML of any web document without the use of inline code. Haml functions as
+# a replacement for inline page templating systems such as PHP, ASP, and ERB, the
+# templating language used in most Ruby on Rails applications. However, Haml
+# avoids the need for explicitly coding HTML into the template, because it itself
+# is a description of the HTML, with some code to generate dynamic content.
+# ({more}[http://haml.info/about.html)]
+#
+# === Example
+#
+#     %html
+#       %head
+#         %title= @title
+#       %body
+#         %h1
+#           Hello
+#           = world + '!'
+#
+# === Usage
+#
+# The <tt>Tilt::HamlTemplate</tt> class is registered for all files ending in <tt>.haml</tt>
+# by default. Haml templates support custom evaluation scopes and locals:
+#
+#     >> require 'haml'
+#     >> template = Tilt.new('hello.haml')
+#     => #<Tilt::HamlTemplate @file='hello.haml'>
+#     >> @title = "Hello Haml!"
+#     >> template.render(self, :world => 'Haml!')
+#     => "
+#     <html>
+#       <head>
+#         <title>Hello Haml!</title>
+#       </head>
+#       <body>
+#         <h1>Hello Haml!</h1>
+#       </body>
+#     </html>"
+#
+# Or, use the <tt>Tilt::HamlTemplate</tt> class directly to process strings:
+#
+#     >> require 'haml'
+#     >> template = Tilt::HamlTemplate.new { "%h1= 'Hello Haml!'" }
+#     => #<Tilt::HamlTemplate @file=nil ...>
+#     >> template.render
+#     => "<h1>Hello Haml!</h1>"
+#
+# __NOTE:__ It's suggested that your program <tt>require 'haml'</tt> at load time when
+# using this template engine within a threaded environment.
+#
+# === Options
+#
+# Please see the {Haml Reference}[http://haml.info/docs/yardoc/file.HAML_REFERENCE.html#options] for all available options.
+#
+# === See also
+#
+# * {#haml.docs}[http://haml.info/docs.html]
+# * {Haml Tutorial}[http://haml.info/tutorial.html]
+# * {Haml Reference}[http://haml.info/docs/yardoc/file.HAML_REFERENCE.html]
+#
+# === Related module
+#
+# * Tilt::HamlTemplate
+
 require_relative 'template'
 require 'haml'
 
@@ -12,7 +78,7 @@ module Tilt
     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.
+      # <tt>Gem::Version.correct?</tt> 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

data/bundle/ruby/3.2.0/gems/tilt-2.8.0/lib/tilt/kramdown.rb

@@ -0,0 +1,59 @@
+# 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
+#
+# Every implementation of Markdown *should* support these options, but there are
+# some known problems with the Kramdown engine.
+#
+# ==== <tt>:smartypants => true|false</tt>
+#
+# Set <tt>true</tt> to enable [Smarty Pants][smartypants] style punctuation replacement.
+#
+# In Kramdown this option only applies to smart quotes. It will apply a
+# subset of Smarty Pants (e.g. <tt>...</tt> to <tt>…</tt>) regardless of any option.
+#
+# ==== <tt>:escape_html => true|false</tt>
+#
+# Kramdown doesn't support this option.
+#
+# === See also
+#
+# * {Markdown Syntax Documentation}[http://daringfireball.net/projects/markdown/syntax]
+# * {Kramdown Markdown implementation}[https://kramdown.gettalong.org]
+
+require_relative 'template'
+require 'kramdown'
+
+dumb_quotes = [39, 39, 34, 34].freeze
+
+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.2.0/gems/tilt-2.8.0/lib/tilt/liquid.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+# = Liquid (<tt>liquid</tt>)
+#
+# 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
+# to #to_h it will be ignored.
+#
+# LiquidTemplate does not support yield blocks.
+#
+# === Example
+#
+#     <html>
+#       <head>
+#         <title>{{ title }}</title>
+#       </head>
+#       <body>
+#         <h1>Hello {{ world }}!</h1>
+#       </body>
+#     </html>
+#
+# === Usage
+#
+# <tt>Tilt::LiquidTemplate</tt> is registered for all files ending in <tt>.liquid</tt> by
+# default. Liquid templates support locals and objects that respond to
+# <tt>#to_h</tt> as scopes:
+#
+#     >> require 'liquid'
+#     >> require 'tilt'
+#     >> template = Tilt.new('hello.liquid')
+#     => #<Tilt::LiquidTemplate @file='hello.liquid'>
+#     >> scope = { :title => "Hello Liquid Templates" }
+#     >> template.render(nil, :world => "Liquid")
+#     => "
+#     <html>
+#       <head>
+#         <title>Hello Liquid Templates</title>
+#       </head>
+#       <body>
+#         <h1>Hello Liquid!</h1>
+#       </body>
+#     </html>"
+#
+# Or, use <tt>Tilt::LiquidTemplate</tt> directly to process strings:
+#
+#     >> require 'liquid'
+#     >> template = Tilt::LiquidTemplate.new { "<h1>Hello Liquid!</h1>" }
+#     => #<Tilt::LiquidTemplate @file=nil ...>
+#     >> template.render
+#     => "<h1>Hello Liquid!</h1>"
+#
+# __NOTE:__ It's suggested that your program <tt>require 'liquid'</tt> at load
+# time when using this template engine within a threaded environment.
+#
+# === See also
+#
+# * {Liquid}[http://liquidmarkup.org]
+# * {Liquid for Programmers}[https://wiki.github.com/Shopify/liquid/liquid-for-programmers]
+# * {Liquid Docs}[http://liquid.rubyforge.org/]
+# * GitHub: {Shopify/liquid}[https://github.com/Shopify/liquid/]
+#
+# === Related module
+#
+# * Tilt::LiquidTemplate
+
+require_relative 'template'
+require 'liquid'
+
+module Tilt
+  class LiquidTemplate < Template
+    def prepare
+      @options[:line_numbers] = true unless @options.has_key?(:line_numbers)
+      @engine = ::Liquid::Template.parse(@data, @options)
+    end
+
+    def evaluate(scope, locs)
+      locals = {}
+      if scope.respond_to?(:to_h)
+        scope.to_h.each{|k, v| locals[k.to_s] = v}
+      end
+      locs.each{|k, v| locals[k.to_s] = v}
+      locals['yield'] = block_given? ? yield : ''
+      locals['content'] = locals['yield']
+      @engine.render(locals)
+    end
+
+    def allows_script?
+      false
+    end
+  end
+end

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

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

data/bundle/ruby/{3.1.0/gems/tilt-2.4.0 → 3.2.0/gems/tilt-2.8.0}/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 <tt>require "rdiscount/template"</tt>, falling
+  # back to <tt>require "kramdown/template"</tt>. If none of these are successful,
   # the first error will be raised.
   class Mapping < BaseMapping
     LOCK = Mutex.new
@@ -237,7 +237,7 @@ module Tilt
     #                             :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]}
+      templates = templates.map{|t| [self[t], t, options[t] || EMPTY_HASH]}
 
       klass = Class.new(Pipeline)
       klass.send(:const_set, :TEMPLATES, templates)
@@ -346,13 +346,13 @@ module Tilt
     end
 
     # The proper behavior (in MRI) for autoload? is to
-    # return `false` when the constant/file has been
+    # return <tt>false</tt> when the constant/file has been
     # explicitly required.
     #
-    # However, in JRuby it returns `true` even after it's
-    # been required. In that case it turns out that `defined?`
-    # returns `"constant"` if it exists and `nil` when it doesn't.
-    # This is actually a second bug: `defined?` should resolve
+    # However, in JRuby it returns <tt>true</tt> even after it's
+    # been required. In that case it turns out that <tt>defined?</tt>
+    # returns <tt>"constant"</tt> if it exists and <tt>nil</tt> when it doesn't.
+    # This is actually a second bug: <tt>defined?</tt> should resolve
     # autoload (aka. actually try to require the file).
     #
     # We use the second bug in order to resolve the first bug.

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

@@ -1,10 +1,19 @@
 # frozen_string_literal: true
+
+# = Markaby
+#
+# === See also
+#
+# * http://github.com/markaby/markaby
+#
+# === Related module
+#
+# * Tilt::MarkabyTemplate
+
 require_relative 'template'
 require 'markaby'
 
 module Tilt
-  # Markaby
-  # http://github.com/markaby/markaby
   class MarkabyTemplate < Template
     def self.builder_class
       @builder_class ||= Class.new(Markaby::Builder) do