brakeman 5.2.1 → 5.3.1

data/bundle/ruby/2.7.0/gems/{ruby_parser-3.18.1 → ruby_parser-3.19.1}/lib/ruby_parser.rb

@@ -80,10 +80,12 @@ require "ruby25_parser"
 require "ruby26_parser"
 require "ruby27_parser"
 require "ruby30_parser"
+require "ruby31_parser"
 
 class RubyParser # HACK
   VERSIONS.clear # also a HACK caused by racc namespace issues
 
+  class V31 < ::Ruby31Parser; end
   class V30 < ::Ruby30Parser; end
   class V27 < ::Ruby27Parser; end
   class V26 < ::Ruby26Parser; end

data/bundle/ruby/2.7.0/gems/{ruby_parser-3.18.1 → ruby_parser-3.19.1}/lib/ruby_parser.yy

@@ -767,8 +767,7 @@ rule
 
            cpath: tCOLON3 cname
                     {
-                      _, (name, line) = val
-                      result = s(:colon3, name.to_sym).line line
+                      result = wrap :colon3, val[1]
                     }
                 | cname
                     {
@@ -793,9 +792,7 @@ rule
 
            fitem: fname
                     {
-                      (id, line), = val
-
-                      result = s(:lit, id.to_sym).line line
+                      result = wrap :lit, val[0]
                     }
                 | symbol
 
@@ -864,9 +861,9 @@ rule
                     }
                 | tCOLON3 tCONSTANT tOP_ASGN arg_rhs
                     {
-                      _, (lhs, line), op, rhs = val
+                      _, lhs, op, rhs = val
 
-                      lhs = s(:colon3, lhs.to_sym).line line
+                      lhs = wrap :colon3, lhs
                       result = new_const_op_asgn [lhs, op, rhs]
                     }
                 | backref tOP_ASGN arg_rhs
@@ -1336,9 +1333,7 @@ rule
                     }
                 | tCOLON3 tCONSTANT
                     {
-                      _, (id, line) = val
-
-                      result = s(:colon3, id.to_sym).line line
+                      result = wrap :colon3, val[1]
                     }
                 | tLBRACK { result = lexer.lineno } aref_args tRBRACK
                     {
@@ -1846,8 +1841,7 @@ opt_block_args_tail: tCOMMA block_args_tail
 
             bvar: tIDENTIFIER
                     {
-                      (id, line), = val
-                      result = s(:shadow, id.to_sym).line line
+                      result = wrap :shadow, val[0]
                     }
                 | f_bad_arg
 
@@ -2458,9 +2452,7 @@ opt_block_args_tail: tCOMMA block_args_tail
 
       p_kw_label: tLABEL
                     {
-                      (id, line), = val
-
-                      result = s(:lit, id.to_sym).line line
+                      result = wrap :lit, val[0]
                     }
 
         p_kwrest: kwrest_mark tIDENTIFIER
@@ -2552,26 +2544,20 @@ opt_block_args_tail: tCOMMA block_args_tail
 
       p_variable: tIDENTIFIER
                     {
-                      (id, line), = val
-
                       # TODO: error_duplicate_pattern_variable(p, $1, &@1);
                       # TODO: assignable(p, $1, 0, &@$);
-                      result = s(:lvar, id.to_sym).line line
+                      result = wrap :lvar, val[0]
                     }
 
        p_var_ref: tCARET tIDENTIFIER
                     {
-                      _, (id, line) = val
-
                       # TODO: check id against env for lvar or dvar
-
-                      result = s(:lvar, id.to_sym).line line
+                      result = wrap :lvar, val[1]
                     }
 
          p_const: tCOLON3 cname
                     {
-                      _, (id, line) = val
-                      result = s(:colon3, id.to_sym).line line
+                      result = wrap :colon3, val[1]
                     }
                 | p_const tCOLON2 cname
                     {
@@ -2583,8 +2569,7 @@ opt_block_args_tail: tCOMMA block_args_tail
                 | tCONSTANT
                     {
                       # TODO $$ = gettable(p, $1, &@$);
-                      (id, line), = val
-                      result = s(:const, id.to_sym).line line
+                      result = wrap :const, val[0]
                     }
 ######################################################################
 #endif
@@ -2871,18 +2856,15 @@ regexp_contents: none
 
      string_dvar: tGVAR
                     {
-                      (id, line), = val
-                      result = s(:gvar, id.to_sym).line line
+                      result = wrap :gvar, val[0]
                     }
                 | tIVAR
                     {
-                      (id, line), = val
-                      result = s(:ivar, id.to_sym).line line
+                      result = wrap :ivar, val[0]
                     }
                 | tCVAR
                     {
-                      (id, line), = val
-                      result = s(:cvar, id.to_sym).line line
+                      result = wrap :cvar, val[0]
                     }
                 | backref
 
@@ -2891,17 +2873,13 @@ regexp_contents: none
 
             ssym: tSYMBEG sym
                     {
-                      _, (id, line) = val
-
                       lexer.lex_state = EXPR_END
-                      result = s(:lit, id.to_sym).line line
+                      result = wrap :lit, val[1]
                     }
                 | tSYMBOL
                     {
-                      (id, line), = val
-
                       lexer.lex_state = EXPR_END
-                      result = s(:lit, id.to_sym).line line
+                      result = wrap :lit, val[0]
                     }
 
              sym: fname | tIVAR | tGVAR | tCVAR
@@ -3422,10 +3400,10 @@ keyword_variable: kNIL      { result = s(:nil).line lexer.lineno }
                     }
                 | tLABEL arg_value
                     {
-                      (label, line), arg = val
+                      label, arg = val
 
-                      lit = s(:lit, label.to_sym).line line
-                      result = s(:array, lit, arg).line line
+                      lit = wrap :lit, label
+                      result = s(:array, lit, arg).line lit.line
                     }
 #if V >= 22
                 | tSTRING_BEG string_contents tLABEL_END arg_value

data/bundle/ruby/2.7.0/gems/{ruby_parser-3.18.1 → ruby_parser-3.19.1}/lib/ruby_parser_extras.rb

@@ -30,7 +30,7 @@ class Sexp
 end
 
 module RubyParserStuff
-  VERSION = "3.18.1"
+  VERSION = "3.19.1"
 
   attr_accessor :lexer, :in_def, :in_single, :file
   attr_accessor :in_kwarg
@@ -218,11 +218,15 @@ module RubyParserStuff
     self.args args
   end
 
+  def attrset_id? id
+    id =~ /^\[\]=$|^\w+=$/
+  end
+
   def endless_method_name defn_or_defs
     name = defn_or_defs[1]
     name = defn_or_defs[2] unless Symbol === name
 
-    if name.end_with? "=" then
+    if attrset_id? name then
       yyerror "setter method cannot be defined in an endless method definition"
     end
 
@@ -978,6 +982,49 @@ module RubyParserStuff
     [result, in_def]
   end
 
+  def new_endless_defn val
+    (name, line, in_def), args, _, body, _, resbody = val
+
+    result =
+      if resbody then
+        s(:defn, name, args,
+          new_rescue(body,
+                     new_resbody(s(:array).line(line),
+                                 resbody))).line line
+      else
+        s(:defn, name, args, body).line line
+      end
+
+    local_pop in_def
+    endless_method_name result
+
+    result.comments = self.comments.pop
+
+    result
+  end
+
+  def new_endless_defs val
+    (recv, (name, line, in_def)), args, _, body, _, resbody = val
+
+    result =
+      if resbody then
+        s(:defs, recv, name, args,
+          new_rescue(body,
+                     new_resbody(s(:array).line(line),
+                                 resbody))).line line
+      else
+        s(:defs, recv, name, args, body).line(line)
+      end
+
+    self.in_single -= 1
+    local_pop in_def
+    endless_method_name result
+
+    result.comments = self.comments.pop
+
+    result
+  end
+
   def new_defs val
     _, recv, (name, line), in_def, args, body, _ = val
 
@@ -1613,6 +1660,12 @@ module RubyParserStuff
 
   alias remove_whitespace_width whitespace_width
 
+  def wrap type, node
+    value, line = node
+    value = value.to_sym if value.respond_to? :to_sym
+    s(type, value).line line
+  end
+
   class Keyword
     include RubyLexer::State::Values
 

data/bundle/ruby/2.7.0/gems/{sexp_processor-4.16.0 → sexp_processor-4.16.1}/History.rdoc

@@ -1,3 +1,9 @@
+=== 4.16.1 / 2022-04-09
+
+* 1 minor enhancement:
+
+  * Reworked ParseTreeTestCase's notion of versions to make it easier to extend.
+
 === 4.16.0 / 2021-10-27
 
 * 4 minor enhancements:

data/bundle/ruby/2.7.0/gems/{sexp_processor-4.16.0 → sexp_processor-4.16.1}/lib/pt_testcase.rb

@@ -34,6 +34,12 @@ class Examples
 end
 
 class ParseTreeTestCase < Minitest::Test
+  all_versions  = %w[18 19 20 21 22 23 24 25 26 27 30 31]
+  most_versions = all_versions.drop(1)
+
+  TEST_SUFFIX = "_#{most_versions.join "_"}"
+  VER_RE      = /(#{Regexp.union(*all_versions)})/
+
   attr_accessor :processor # to be defined by subclass
 
   def setup
@@ -77,7 +83,7 @@ class ParseTreeTestCase < Minitest::Test
   end
 
   def self.add_19tests name, hash
-    add_tests "#{name}__19_20_21_22_23_24_25_26_27_30", hash # HACK?
+    add_tests "#{name}_#{TEST_SUFFIX}", hash # HACK?
   end
 
   def self.add_19edgecases ruby, sexp, cases
@@ -102,8 +108,6 @@ class ParseTreeTestCase < Minitest::Test
     testcases[verbose][klass] = testcases[nonverbose][klass]
   end
 
-  VER_RE = "(1[89]|2[01234567]|3[0])"
-
   def self.generate_test klass, node, data, input_name, output_name
     klass.send :define_method, "test_#{node}" do
       flunk "Processor is nil" if processor.nil?

data/bundle/ruby/2.7.0/gems/{sexp_processor-4.16.0 → sexp_processor-4.16.1}/lib/sexp_processor.rb

@@ -34,7 +34,7 @@ require "sexp"
 class SexpProcessor
 
   # duh
-  VERSION = "4.16.0"
+  VERSION = "4.16.1"
 
   ##
   # Automatically shifts off the Sexp type before handing the

data/bundle/ruby/2.7.0/gems/{tilt-2.0.10 → tilt-2.0.11}/lib/tilt/commonmarker.rb

@@ -9,21 +9,31 @@ module Tilt
       :smartypants => :SMART
     }
     PARSE_OPTIONS = [
+      :FOOTNOTES,
+      :LIBERAL_HTML_TAG,
       :SMART,
       :smartypants,
+      :STRIKETHROUGH_DOUBLE_TILDE,
+      :UNSAFE,
+      :VALIDATE_UTF8,
     ].freeze
     RENDER_OPTIONS = [
+      :FOOTNOTES,
+      :FULL_INFO_STRING,
       :GITHUB_PRE_LANG,
       :HARDBREAKS,
       :NOBREAKS,
-      :SAFE,
+      :SAFE, # Removed in v0.18.0 (2018-10-17)
       :SOURCEPOS,
+      :TABLE_PREFER_STYLE_ATTRIBUTES,
+      :UNSAFE,
     ].freeze
     EXTENSIONS = [
       :autolink,
       :strikethrough,
       :table,
       :tagfilter,
+      :tasklist,
     ].freeze
 
     def extensions

data/bundle/ruby/2.7.0/gems/{tilt-2.0.10 → tilt-2.0.11}/lib/tilt/csv.rb

@@ -50,7 +50,7 @@ module Tilt
 
     def precompiled_template(locals)
       <<-RUBY
-        #{@outvar} = #{self.class.engine}.generate(#{options}) do |csv|
+        #{@outvar} = #{self.class.engine}.generate(**#{options}) do |csv|
           #{data}
         end
       RUBY

data/bundle/ruby/2.7.0/gems/{tilt-2.0.10 → tilt-2.0.11}/lib/tilt/pandoc.rb

@@ -7,30 +7,38 @@ module Tilt
   class PandocTemplate < Template
     self.default_mime_type = 'text/html'
 
-    def tilt_to_pandoc_mapping
-      { :smartypants => :smart,
-        :escape_html => { :f => 'markdown-raw_html' },
-        :commonmark => { :f => 'commonmark' },
-        :markdown_strict => { :f => 'markdown_strict' }
-      }
-    end
-
     # 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
     def pandoc_options
-      options.reduce([]) do |sum, (k,v)|
-        case v
-        when true
-          sum << (tilt_to_pandoc_mapping[k] || k)
-        when false
-          sum
+      result = []
+      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
-          sum << { k => v }
+          case v
+          when true
+            result << k
+          when false
+            # do nothing
+          else
+            result << { k => v }
+          end
         end
       end
+      result << { :f => from + smart_extension }
+      result
     end
 
     def prepare

data/bundle/ruby/2.7.0/gems/{tilt-2.0.10 → tilt-2.0.11}/lib/tilt/redcarpet.rb

@@ -75,9 +75,12 @@ module Tilt
   end
 
   if defined? ::Redcarpet::Render and defined? ::Redcarpet::Markdown
-    RedcarpetTemplate = Redcarpet2Template
+    superclass = Redcarpet2Template
   else
-    RedcarpetTemplate = Redcarpet1Template
+    superclass = Redcarpet1Template
+  end
+
+  class RedcarpetTemplate < superclass
   end
 end
 

data/bundle/ruby/2.7.0/gems/tilt-2.0.11/lib/tilt/rst-pandoc.rb

@@ -0,0 +1,23 @@
+require 'tilt/template'
+require 'pandoc'
+
+module Tilt
+  # Pandoc reStructuredText implementation. See:
+  # http://pandoc.org/
+  class RstPandocTemplate < PandocTemplate
+    self.default_mime_type = 'text/html'
+
+    def prepare
+      @engine = PandocRuby.new(data, :f => "rst")
+      @output = nil
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= @engine.to_html.strip
+    end
+
+    def allows_script?
+      false
+    end
+  end
+end

data/bundle/ruby/2.7.0/gems/tilt-2.0.11/lib/tilt/sass.rb

@@ -0,0 +1,78 @@
+require 'tilt/template'
+
+module Tilt
+  # Sass template implementation. See:
+  # http://haml.hamptoncatlin.com/
+  #
+  # Sass templates do not support object scopes, locals, or yield.
+  class SassTemplate < Template
+    self.default_mime_type = 'text/css'
+
+    begin
+      require 'sass-embedded'
+      require 'uri'
+      Engine = nil
+    rescue LoadError => err
+      begin
+        require 'sassc'
+        Engine = ::SassC::Engine
+      rescue LoadError
+        begin
+          require 'sass'
+          Engine = ::Sass::Engine
+        rescue LoadError
+          raise err
+        end
+      end
+    end
+
+    def prepare
+      @engine = unless Engine.nil?
+                  Engine.new(data, sass_options)
+                end
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= if @engine.nil?
+                    ::Sass.compile_string(data, **sass_embedded_options).css
+                  else
+                    @engine.render
+                  end
+    end
+
+    def allows_script?
+      false
+    end
+
+  private
+    def eval_file_url
+      path = File.absolute_path(eval_file)
+      path = '/' + path unless path.start_with?('/')
+      ::URI::File.build([nil, ::URI::DEFAULT_PARSER.escape(path)]).to_s
+    end
+
+    def sass_embedded_options
+      options.merge(:url => eval_file_url, :syntax => :indented)
+    end
+
+    def sass_options
+      options.merge(:filename => eval_file, :line => line, :syntax => :sass)
+    end
+  end
+
+  # Sass's new .scss type template implementation.
+  class ScssTemplate < SassTemplate
+    self.default_mime_type = 'text/css'
+
+  private
+    def sass_embedded_options
+      options.merge(:url => eval_file_url, :syntax => :scss)
+    end
+
+    def sass_options
+      options.merge(:filename => eval_file, :line => line, :syntax => :scss)
+    end
+  end
+
+end
+

data/bundle/ruby/2.7.0/gems/{tilt-2.0.10 → tilt-2.0.11}/lib/tilt/template.rb

@@ -157,6 +157,8 @@ module Tilt
       raise NotImplementedError
     end
 
+    CLASS_METHOD = Kernel.instance_method(:class)
+
     # Execute the compiled template and return the result string. Template
     # evaluation is guaranteed to be performed in the scope object with the
     # locals specified and with support for yielding to the block.
@@ -166,7 +168,16 @@ module Tilt
     def evaluate(scope, locals, &block)
       locals_keys = locals.keys
       locals_keys.sort!{|x, y| x.to_s <=> y.to_s}
-      method = compiled_method(locals_keys, scope.is_a?(Module) ? scope : scope.class)
+      case scope
+      when Object
+        method = compiled_method(locals_keys, Module === scope ? scope : scope.class)
+      else
+        if RUBY_VERSION >= '2'
+          method = compiled_method(locals_keys, CLASS_METHOD.bind(scope).call)
+        else
+          method = compiled_method(locals_keys, Object)
+        end
+      end
       method.bind(scope).call(locals, &block)
     end