brakeman 7.1.2 → 8.0.6

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

@@ -1,26 +1,37 @@
 # frozen_string_literal: true
+
+# = Prawn
+#
+# Prawn template implementation.
+#
+# === See also
+#
+# * http://prawnpdf.org
+#
+# === Related module
+#
+# * Tilt::PrawnTemplate
+
 require_relative 'template'
 require 'prawn'
 
 module Tilt
-  # Prawn template implementation. See: http://prawnpdf.org
   class PrawnTemplate < Template
     self.default_mime_type = 'application/pdf'
-    
+
     def prepare
       @options[:page_size] = 'A4' unless @options.has_key?(:page_size)
       @options[:page_layout] = :portrait unless @options.has_key?(:page_layout)
-      @engine = ::Prawn::Document.new(@options)
     end
-    
+
     def evaluate(scope, locals, &block)
-      pdf = @engine
+      pdf = ::Prawn::Document.new(@options)
       locals = locals.dup
       locals[:pdf] = pdf
       super
       pdf.render
     end
-    
+
     def precompiled_template(locals)
       @data.to_str
     end

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+# = Radius (<tt>radius</tt>)
+#
+# {Radius}[http://radius.rubyforge.org] is the template language used by {Radiant CMS}[http://radiantcms.org]. It is
+# a tag language designed to be valid XML/HTML.
+#
+# === Example
+#
+#     <html>
+#     <body>
+#       <h1><r:title /></h1>
+#       <ul class="<r:type />">
+#       <r:repeat times="3">
+#         <li><r:hello />!</li>
+#       </r:repeat>
+#       </ul>
+#       <r:yield />
+#     </body>
+#     </html>
+#
+# === Usage
+#
+# To render a template such as the one above.
+#
+#     scope = OpenStruct.new
+#     scope.title = "Radius Example"
+#     scope.hello = "Hello, World!"
+#
+#     require 'radius'
+#     template = Tilt::RadiusTemplate.new('example.radius', :tag_prefix=>'r')
+#     template.render(scope, :type=>'hlist'){ "Jackpot!" }
+#
+# The result will be:
+#
+#     <html>
+#     <body>
+#       <h1>Radius Example</h1>
+#       <ul class="hlist">
+#         <li>Hello, World!</li>
+#         <li>Hello, World!</li>
+#         <li>Hello, World!</li>
+#       </ul>
+#       Jackpot!
+#     </body>
+#     </html>
+#
+# === See also
+#
+# * {Radius}[http://radius.rubyforge.org]
+# * {Radiant CMS}[http://radiantcms.org]
+#
+# === Related module
+#
+# * Tilt::RadiusTemplate
+
+require_relative 'template'
+require 'radius'
+
+module Tilt
+  # Radius Template
+  # http://github.com/jlong/radius/
+  class RadiusTemplate < Template
+    class ContextClass < Radius::Context
+      attr_accessor :tilt_scope
+
+      def tag_missing(name, attributes)
+        tilt_scope.__send__(name)
+      end
+
+      def dup
+        i = super
+        i.tilt_scope = tilt_scope
+        i
+      end
+    end
+
+    def evaluate(scope, locals, &block)
+      context = ContextClass.new
+      context.tilt_scope = scope
+      context.define_tag("yield", &block) if block
+      locals.each do |tag, value|
+        context.define_tag(tag) do
+          value
+        end
+      end
+
+      @options[:tag_prefix] = 'r' unless @options.has_key?(:tag_prefix)
+      Radius::Parser.new(context, @options).parse(@data)
+    end
+
+    def allows_script?
+      false
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+# = RDiscount (<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.
+#
+# RDiscount is a simple text filter. It does not support +scope+ or
+# +locals+. The +:smart+ and +:filter_html+ options may be set true
+# to enable those flags on the underlying RDiscount object.
+#
+# === 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]
+#  * [Discount][discount]
+#  * {RDiscount}[http://github.com/rtomayko/rdiscount]
+#
+# -----------------------------------
+#
+# [Discount][discount] is an implementation of the Markdown markup language in C.
+# [RDiscount][rdiscount] is a Ruby wrapper around Discount.
+#
+# All the documentation of {Markdown}[#markdown] applies in addition to the following:
+#
+# === Usage
+#
+# The <tt>Tilt::RDiscountTemplate</tt> class is registered for all files ending in
+# <tt>.markdown</tt>, <tt>.md</tt> or <tt>.mkd</tt> by default with the highest priority. If you
+# specifically want to use RDiscount, it's recommended to use <tt>#prefer</tt>:
+#
+#     Tilt.prefer Tilt::RDiscountTemplate
+#
+# __NOTE:__ It's suggested that your program <tt>require 'rdiscount'</tt> at load time when
+# using this template engine within a threaded environment.
+
+require_relative 'template'
+require 'rdiscount'
+
+aliases = {
+  :escape_html => :filter_html,
+  :smartypants => :smart
+}.freeze
+
+_flags = [:smart, :filter_html, :smartypants, :escape_html].freeze
+
+Tilt::RDiscountTemplate = Tilt::StaticTemplate.subclass do
+  flags = _flags.select { |flag| @options[flag] }.
+    map! { |flag| aliases[flag] || flag }
+
+  RDiscount.new(@data, *flags).to_html
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# = RDoc (<tt>rdoc</tt>)
+#
+# {RDoc}[http://rdoc.rubyforge.org] is the simple text markup system that comes with Ruby's standard
+# library.
+#
+# === Example
+#
+#     = Hello RDoc Templates
+#
+#     Hello World. This is a paragraph.
+#
+# === Usage
+#
+# __NOTE:__ It's suggested that your program <tt>require 'rdoc'</tt>,
+# <tt>require 'rdoc/markup'</tt>, and <tt>require 'rdoc/markup/to_html'</tt> at load time
+# when using this template engine in a threaded environment.
+#
+# === See also
+#
+# * {RDoc}[http://rdoc.rubyforge.org]
+# * {RDoc Github}[https://github.com/ruby/rdoc]
+
+require_relative 'template'
+require 'rdoc'
+require 'rdoc/markup'
+require 'rdoc/markup/to_html'
+require 'rdoc/options'
+
+Tilt::RDocTemplate = if defined?(RDoc::VERSION) && RDoc::VERSION >= "8"
+  Tilt::StaticTemplate.subclass do
+    RDoc::Markup::ToHtml.new.convert(@data).to_s
+  end
+# :nocov:
+else
+  Tilt::StaticTemplate.subclass do
+    RDoc::Markup::ToHtml.new(RDoc::Options.new, nil).convert(@data).to_s
+  end
+end
+# :nocov:

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

@@ -0,0 +1,73 @@
+# 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]
+
+require_relative 'template'
+require 'redcarpet'
+
+aliases = {:escape_html => :filter_html, :smartypants => :smart}.freeze
+
+Tilt::RedcarpetTemplate = Tilt::StaticTemplate.subclass do
+  aliases.each do |opt, aka|
+    if options.key?(aka) || !@options.key?(opt)
+      @options[opt] = @options.delete(aka)
+    end
+  end
+
+  # only raise an exception if someone is trying to enable :escape_html
+  @options.delete(:escape_html) unless @options[:escape_html]
+
+  renderer = @options.delete(:renderer) || ::Redcarpet::Render::HTML.new(@options)
+  if options.delete(:smartypants) && !(renderer.is_a?(Class) && renderer <= ::Redcarpet::Render::SmartyPants)
+    renderer = if renderer == ::Redcarpet::Render::XHTML
+      ::Redcarpet::Render::SmartyHTML.new(:xhtml => true)
+    elsif renderer == ::Redcarpet::Render::HTML
+      ::Redcarpet::Render::SmartyHTML
+    elsif renderer.is_a? Class
+      Class.new(renderer) { include ::Redcarpet::Render::SmartyPants }
+    else
+      renderer.extend ::Redcarpet::Render::SmartyPants
+    end
+  end
+
+  Redcarpet::Markdown.new(renderer, @options).render(@data)
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+# = Textile (<tt>textile</tt>)
+#
+# Textile is a lightweight markup language originally developed by Dean Allen and
+# billed as a "humane Web text generator". Textile converts its marked-up text
+# input to valid, well-formed XHTML and also inserts character entity references
+# for apostrophes, opening and closing single and double quotation marks,
+# ellipses and em dashes.
+#
+# Textile formatted texts are converted to HTML with the {RedCloth}[http://redcloth.org]
+# engine, which is a Ruby extension written in C.
+#
+# === Example
+#
+#     h1. Hello Textile Templates
+#
+#     Hello World. This is a paragraph.
+#
+# === Usage
+#
+# __NOTE:__ It's suggested that your program <tt>require 'redcloth'</tt> at load time
+# when using this template engine in a threaded environment.
+#
+# === See Also
+#
+# * {RedCloth}[http://redcloth.org]
+# * https://github.com/jgarber/redcloth
+
+require_relative 'template'
+require 'redcloth'
+
+Tilt::RedClothTemplate = Tilt::StaticTemplate.subclass do
+  engine = RedCloth.new(@data)
+  @options.each  do |k, v|
+    m = :"#{k}="
+    engine.send(m, v) if engine.respond_to? m
+  end
+  engine.to_html
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# = reStructuredText (<tt>rst</tt>)
+#
+# reStructuredText is a lightweight markup language originally developed by David Goodger,
+# based on StructuredText and Setext. reStructuredText is primarily used for technical
+# documentation in the Python programming language community, e.g. by the
+# {Sphinx}[http://www.sphinx-doc.org/en/stable/rest.html] Python documentation generator.
+#
+# reStructuredText formatted texts are converted to HTML with {Pandoc}[http://pandoc.org/], which
+# is an application written in Haskell, with a Ruby wrapper provided by the
+# {pandoc-ruby}[https://github.com/alphabetum/pandoc-ruby] gem.
+#
+# === Example
+#
+#     Hello Rst Templates
+#     ===================
+#
+#     Hello World. This is a paragraph.
+#
+# === See Also
+#
+# * {Pandoc}[http://pandoc.org/]
+# * {pandoc-ruby}[https://github.com/alphabetum/pandoc-ruby]
+
+require_relative 'template'
+require_relative 'pandoc'
+
+rst = {:f => "rst"}.freeze
+
+Tilt::RstPandocTemplate = Tilt::StaticTemplate.subclass do
+  PandocRuby.new(@data, rst).to_html.strip
+end

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

@@ -1,10 +1,23 @@
 # frozen_string_literal: true
+
+# = Sass / Scss
+#
+# Sass/Scss template implementation for generating CSS.
+#
+# Sass templates do not support object scopes, locals, or yield.
+#
+# === See also
+#
+# * https://sass-lang.com/
+#
+# === Related modules
+#
+# * Tilt::SassTemplate
+# * Tilt::ScssTemplate
+
 require_relative 'template'
 
 module Tilt
-  # Sass template implementation for generating CSS. See: https://sass-lang.com/
-  #
-  # Sass templates do not support object scopes, locals, or yield.
   class SassTemplate < StaticTemplate
     self.default_mime_type = 'text/css'
 

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# = Slim (<tt>slim</tt>)
+#
+# === Embedded locals
+#
+# In slim templates, the comment format looks like this:
+#
+#   //# locals: ()
+#
+# === See also
+#
+# * https://slim-template.github.io
+
+require_relative 'template'
+require 'slim'
+
+Tilt::SlimTemplate = Slim::Template

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

@@ -1,9 +1,17 @@
 # frozen_string_literal: true
+
+# = String
+#
+# The template source is evaluated as a Ruby string. The #{} interpolation
+# syntax can be used to generated dynamic output.
+#
+# === Related module
+#
+# * Tilt::StringTemplate
+
 require_relative 'template'
 
 module Tilt
-  # The template source is evaluated as a Ruby string. The #{} interpolation
-  # syntax can be used to generated dynamic output.
   class StringTemplate < Template
     def prepare
       hash = "TILT#{@data.hash.abs}"

data/bundle/ruby/3.2.0/gems/{tilt-2.6.1 → tilt-2.8.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
@@ -376,10 +376,10 @@ 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
 

data/bundle/ruby/3.2.0/gems/{tilt-2.6.1 → tilt-2.8.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.8.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.2.0/gems/{tilt-2.6.1 → tilt-2.8.0}/lib/tilt.rb

@@ -5,7 +5,7 @@ require_relative 'tilt/template'
 # Namespace for Tilt. This module is not intended to be included anywhere.
 module Tilt
   # Current version.
-  VERSION = '2.6.1'
+  VERSION = '2.8.0'
 
   EMPTY_ARRAY = [].freeze
   private_constant :EMPTY_ARRAY
@@ -163,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'

data/lib/brakeman/app_tree.rb

@@ -120,7 +120,7 @@ module Brakeman
 
     def template_paths
       @template_paths ||= find_paths(".", "*.{#{VIEW_EXTENSIONS}}") +
-        find_paths("**", "*.{erb,haml,slim}").reject { |path| File.basename(path).count(".") > 1 }
+        find_paths(".", "*.{erb,haml,slim}").reject { |path| File.basename(path).count(".") > 1 }
     end
 
     def layout_exists?(name)
@@ -213,13 +213,17 @@ module Brakeman
     end
 
     def reject_directories(paths)
-      paths.reject { |path| File.directory?(path) }
+      paths.reject do |path|
+        Brakeman.logger.spin
+        File.directory?(path)
+      end
     end
 
     def select_only_files(paths)
       return paths unless @only_files
 
       paths.select do |path|
+        Brakeman.logger.spin
         match_path @only_files, path
       end
     end
@@ -228,6 +232,7 @@ module Brakeman
       return paths unless @skip_files
 
       paths.reject do |path|
+        Brakeman.logger.spin
         match_path @skip_files, path
       end
     end

data/lib/brakeman/checks/check_eol_rails.rb

@@ -25,6 +25,7 @@ class Brakeman::CheckEOLRails < Brakeman::EOLCheck
     ['7.0.0', '7.0.99'] => Date.new(2025, 4, 1),
     ['7.1.0', '7.1.99'] => Date.new(2025, 10, 1),
     ['7.2.0', '7.2.99'] => Date.new(2026, 8, 9),
-    ['8.0.0', '8.0.99'] => Date.new(2026, 10, 7),
+    ['8.0.0', '8.0.99'] => Date.new(2026, 11, 7),
+    ['8.1.0', '8.1.99'] => Date.new(2027, 10, 10),
   }
 end

data/lib/brakeman/checks/check_eol_ruby.rb

@@ -26,5 +26,6 @@ class Brakeman::CheckEOLRuby < Brakeman::EOLCheck
     ['3.2.0', '3.2.99'] => Date.new(2026, 3, 31),
     ['3.3.0', '3.3.99'] => Date.new(2027, 3, 31),
     ['3.4.0', '3.4.99'] => Date.new(2028, 3, 31),
+    ['4.0.0', '4.0.99'] => Date.new(2029, 3, 31),
   }
 end