brakeman 7.1.2 → 8.0.6

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.2.0/gems/{tilt-2.6.1 → 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.2.0/gems/{tilt-2.6.1 → 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.2.0/gems/{tilt-2.6.1 → 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.2.0/gems/{tilt-2.6.1 → 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.2.0/gems/{tilt-2.6.1 → tilt-2.8.0}/lib/tilt/mapping.rb

@@ -119,8 +119,8 @@ module Tilt
   #     # => RDiscount::Template
   #
   # In the previous example we say that RDiscount has a *higher priority* than
-  # Kramdown. Tilt will first try to `require "rdiscount/template"`, falling
-  # back to `require "kramdown/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.2.0/gems/{tilt-2.6.1 → 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

data/bundle/ruby/3.2.0/gems/{tilt-2.6.1 → tilt-2.8.0}/lib/tilt/nokogiri.rb

@@ -1,10 +1,21 @@
 # frozen_string_literal: true
+
+# = Nokogiri
+#
+# Nokogiri template implementation.
+#
+# === See also
+#
+# * http://nokogiri.org/
+#
+# === Related module
+#
+# * Tilt::NokogiriTemplate
+
 require_relative 'template'
 require 'nokogiri'
 
 module Tilt
-  # Nokogiri template implementation. See:
-  # http://nokogiri.org/
   class NokogiriTemplate < Template
     DOCUMENT_HEADER = /\A<\?xml version=\"1\.0\"\?>\n?/
     self.default_mime_type = 'text/xml'

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+# = Markdown (<tt>markdown</tt>, <tt>md</tt>, <tt>mkd</tt>)
+#
+# {Markdown}[http://daringfireball.net/projects/markdown/syntax] 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]
+# * {Pandoc}[http://pandoc.org]
+
+require_relative 'template'
+require 'pandoc-ruby'
+
+Tilt::PandocTemplate = Tilt::StaticTemplate.subclass do
+  # turn options hash into an array
+  # Map tilt options to pandoc options
+  # Replace hash keys with value true with symbol for key
+  # Remove hash keys with value false
+  # Leave other hash keys untouched
+  pandoc_options = []
+  from = "markdown"
+  smart_extension = "-smart"
+  @options.each do |k,v|
+    case k
+    when :smartypants
+      smart_extension = "+smart" if v
+    when :escape_html
+      from = "markdown-raw_html" if v
+    when :commonmark
+      from = "commonmark" if v
+    when :markdown_strict
+      from = "markdown_strict" if v
+    else
+      case v
+      when true
+        pandoc_options << k
+      when false
+        # do nothing
+      else
+        pandoc_options << { k => v }
+      end
+    end
+  end
+  pandoc_options << { :f => from + smart_extension }
+
+  PandocRuby.new(@data, *pandoc_options).to_html.strip
+end

data/bundle/ruby/3.2.0/gems/{tilt-2.6.1 → tilt-2.8.0}/lib/tilt/pipeline.rb

@@ -1,12 +1,17 @@
 # frozen_string_literal: true
+
 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)|
+      @pipeline = self.class::TEMPLATES.inject(proc{|*| data}) do |data, (klass, ext, options)|
         proc do |s,l,&sb|
+          options = options
+          if ext_opts = @options[ext]
+            options = options.merge(ext_opts)
+          end
           klass.new(file, line, options, &proc{|*| data.call(s, l, &sb)}).render(s, l, &sb)
         end
       end

data/bundle/ruby/3.2.0/gems/{tilt-2.6.1 → tilt-2.8.0}/lib/tilt/plain.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
-require_relative 'template'
 
+# = Plain
+#
 # Raw text (no template functionality).
+
+require_relative 'template'
+
 Tilt::PlainTemplate = Tilt::StaticTemplate.subclass{@data}