brakeman 4.8.0 → 5.2.1

data/bundle/ruby/2.7.0/gems/{ruby_parser-3.14.2 → ruby_parser-3.18.1}/lib/ruby_lexer.rex

@@ -4,11 +4,16 @@
 
 class RubyLexer
 
+option
+
+  lineno
+  column
+
 macro
 
-  IDENT         /^#{IDENT_CHAR}+/o
+  IDENT_CHAR    /[a-zA-Z0-9_[:^ascii:]]/
 
-  ESC           /\\((?>[0-7]{1,3}|x[0-9a-fA-F]{1,2}|M-[^\\]|(C-|c)[^\\]|u[0-9a-fA-F]{1,4}|u\{[0-9a-fA-F]+\}|[^0-7xMCc]))/
+  ESC           /\\((?>[0-7]{1,3}|x\h{1,2}|M-[^\\]|(C-|c)[^\\]|u\h{1,4}|u\{\h+(?:\s+\h+)*\}|[^0-7xMCc]))/
   SIMPLE_STRING /((#{ESC}|\#(#{ESC}|[^\{\#\@\$\"\\])|[^\"\\\#])*)/o
   SSTRING       /((\\.|[^\'])*)/
 
@@ -25,7 +30,8 @@ macro
 
 start
 
-  return process_string if lex_strterm
+  maybe_pop_stack
+  return process_string_or_heredoc if lex_strterm
 
   self.cmd_state = self.command_start
   self.command_start = false
@@ -37,18 +43,18 @@ rule
 # [:state]      pattern                 [actions]
 
                 # \s - \n + \v
-                /[\ \t\r\f\v]/          { self.space_seen = true; next }
+                /[\ \t\r\f\v]+/         { self.space_seen = true; next }
 
                 /\n|\#/                 process_newline_or_comment
 
                 /[\]\)\}]/              process_brace_close
 
 : /\!/
-| is_after_operator? /\!\@/             { result EXPR_ARG, :tUBANG, "!@" }
+| is_after_operator? /\!\@/             { result EXPR_ARG,   TOKENS[text], text }
 |               /\![=~]?/               { result :arg_state, TOKENS[text], text }
 
 : /\./
-|               /\.\.\.?/               { result EXPR_BEG, TOKENS[text], text }
+|               /\.\.\.?/               process_dots
 |               /\.\d/                  { rb_compile_error "no .<digit> floating literal anymore put 0 before dot" }
 |               /\./                    { self.lex_state = EXPR_BEG; result EXPR_DOT, :tDOT, "." }
 
@@ -62,8 +68,8 @@ rule
 |               /\=(?=begin\b)/         { result arg_state, TOKENS[text], text }
 
 ruby22_label?   /\"#{SIMPLE_STRING}\":/o process_label
-                /\"(#{SIMPLE_STRING})\"/o { result EXPR_END, :tSTRING, text[1..-2].gsub(ESC) { unescape $1 } }
-                /\"/                    { string STR_DQUOTE; result nil, :tSTRING_BEG, text }
+                /\"(#{SIMPLE_STRING})\"/o process_simple_string
+                /\"/                    { string STR_DQUOTE, '"'; result nil, :tSTRING_BEG, text }
 
                 /\@\@?\d/               { rb_compile_error "`#{text}` is not allowed as a variable name" }
                 /\@\@?#{IDENT_CHAR}+/o  process_ivar
@@ -75,7 +81,7 @@ ruby22_label?   /\"#{SIMPLE_STRING}\":/o process_label
 |               /\:\:/                      process_colon2
 |               /\:/                        process_colon1
 
-                /->/                    { result EXPR_ENDFN, :tLAMBDA, nil }
+                /->/                    { result EXPR_ENDFN, :tLAMBDA, text }
 
                 /[+-]/                  process_plus_minus
 
@@ -94,6 +100,7 @@ ruby22_label?   /\"#{SIMPLE_STRING}\":/o process_label
                 /\[/                    process_square_bracket
 
 was_label?        /\'#{SSTRING}\':?/o   process_label_or_string
+                  /\'/                  { string STR_SQUOTE, "'"; result nil, :tSTRING_BEG, text }
 
 : /\|/
 |               /\|\|\=/                { result EXPR_BEG, :tOP_ASGN, "||" }
@@ -105,9 +112,9 @@ was_label?        /\'#{SSTRING}\':?/o   process_label_or_string
 
 : /\*/
 |               /\*\*=/                 { result EXPR_BEG, :tOP_ASGN, "**" }
-|               /\*\*/                  { result(:arg_state, space_vs_beginning(:tDSTAR, :tDSTAR, :tPOW), "**") }
-|               /\*\=/                  { result(EXPR_BEG, :tOP_ASGN, "*") }
-|               /\*/                    { result(:arg_state, space_vs_beginning(:tSTAR, :tSTAR, :tSTAR2), "*") }
+|               /\*\*/                  { result :arg_state, space_vs_beginning(:tDSTAR, :tDSTAR, :tPOW), "**" }
+|               /\*\=/                  { result EXPR_BEG, :tOP_ASGN, "*" }
+|               /\*/                    { result :arg_state, space_vs_beginning(:tSTAR, :tSTAR, :tSTAR2), "*" }
 
 # TODO: fix result+process_lchevron to set command_start = true
 : /</
@@ -124,30 +131,30 @@ was_label?        /\'#{SSTRING}\':?/o   process_label_or_string
 |               /\>/                    { result :arg_state, :tGT, ">"       }
 
 : /\`/
-| expr_fname?   /\`/                   { result(EXPR_END, :tBACK_REF2, "`") }
+| expr_fname?   /\`/                   { result EXPR_END, :tBACK_REF2, "`" }
 | expr_dot?     /\`/                   { result((cmd_state ? EXPR_CMDARG : EXPR_ARG), :tBACK_REF2, "`") }
-|               /\`/                   { string STR_XQUOTE, '`'; result(nil, :tXSTRING_BEG, "`") }
+|               /\`/                   { string STR_XQUOTE, '`'; result nil, :tXSTRING_BEG, "`" }
 
                 /\?/                    process_questionmark
 
 : /&/
-|               /\&\&\=/                { result(EXPR_BEG, :tOP_ASGN, "&&") }
-|               /\&\&/                  { result(EXPR_BEG, :tANDOP,   "&&") }
-|               /\&\=/                  { result(EXPR_BEG, :tOP_ASGN, "&" ) }
-|               /\&\./                  { result(EXPR_DOT, :tLONELY,  "&.") }
+|               /\&\&\=/                { result EXPR_BEG, :tOP_ASGN, "&&" }
+|               /\&\&/                  { result EXPR_BEG, :tANDOP,   "&&" }
+|               /\&\=/                  { result EXPR_BEG, :tOP_ASGN, "&"  }
+|               /\&\./                  { result EXPR_DOT, :tLONELY,  "&." }
 |               /\&/                    process_amper
 
                 /\//                    process_slash
 
 : /\^/
-|               /\^=/                   { result(EXPR_BEG, :tOP_ASGN, "^") }
-|               /\^/                    { result(:arg_state, :tCARET, "^") }
+|               /\^=/                   { result EXPR_BEG, :tOP_ASGN, "^" }
+|               /\^/                    { result :arg_state, :tCARET, "^" }
 
-                /\;/                    { self.command_start = true; result(EXPR_BEG, :tSEMI, ";") }
+                /\;/                    { self.command_start = true; result EXPR_BEG, :tSEMI, ";" }
 
 : /~/
-| is_after_operator? /\~@/              { result(:arg_state, :tTILDE, "~") }
-|               /\~/                    { result(:arg_state, :tTILDE, "~") }
+| is_after_operator? /\~@/              { result :arg_state, :tTILDE, "~" }
+|               /\~/                    { result :arg_state, :tTILDE, "~" }
 
 : /\\/
 |               /\\\r?\n/               { self.lineno += 1; self.space_seen = true; next }
@@ -164,13 +171,12 @@ was_label?        /\'#{SSTRING}\':?/o   process_label_or_string
 | in_fname?     /\$([1-9]\d*)/                   process_gvar
 |               /\$([1-9]\d*)/                   process_nthref
 |               /\$0/                            process_gvar
-|               /\$[^[:ascii:]]+/                process_gvar
-|               /\$\W|\$\z/                      process_gvar_oddity
-|               /\$\w+/                          process_gvar
+|               /\$#{IDENT_CHAR}+/               process_gvar
+|               /\$\W/                           process_gvar_oddity
 
                 /\_/                    process_underscore
 
-                /#{IDENT}/o             process_token
+                /#{IDENT_CHAR}+/o       process_token
 
                 /\004|\032|\000|\Z/     { [RubyLexer::EOF, RubyLexer::EOF] }
 

data/bundle/ruby/2.7.0/gems/{ruby_parser-3.14.2 → ruby_parser-3.18.1}/lib/ruby_lexer.rex.rb

@@ -1,7 +1,8 @@
+# frozen_string_literal: true
 # encoding: UTF-8
 #--
 # This file is automatically generated. Do not modify it.
-# Generated by: oedipus_lex version 2.5.1.
+# Generated by: oedipus_lex version 2.6.0.
 # Source: lib/ruby_lexer.rex
 #++
 
@@ -16,8 +17,8 @@ class RubyLexer
   require 'strscan'
 
   # :stopdoc:
-  IDENT         = /^#{IDENT_CHAR}+/o
-  ESC           = /\\((?>[0-7]{1,3}|x[0-9a-fA-F]{1,2}|M-[^\\]|(C-|c)[^\\]|u[0-9a-fA-F]{1,4}|u\{[0-9a-fA-F]+\}|[^0-7xMCc]))/
+  IDENT_CHAR    = /[a-zA-Z0-9_[:^ascii:]]/
+  ESC           = /\\((?>[0-7]{1,3}|x\h{1,2}|M-[^\\]|(C-|c)[^\\]|u\h{1,4}|u\{\h+(?:\s+\h+)*\}|[^0-7xMCc]))/
   SIMPLE_STRING = /((#{ESC}|\#(#{ESC}|[^\{\#\@\$\"\\])|[^\"\\\#])*)/o
   SSTRING       = /((\\.|[^\'])*)/
   INT_DEC       = /[+]?(?:(?:[1-9][\d_]*|0)(?!\.\d)(ri|r|i)?\b|0d[0-9_]+)(ri|r|i)?/i
@@ -35,6 +36,10 @@ class RubyLexer
   class ScanError < LexerError ; end
   # :startdoc:
 
+  ##
+  # The current line number.
+
+  attr_accessor :lineno
   ##
   # The file name / path
 
@@ -68,6 +73,24 @@ class RubyLexer
     yield
   end
 
+  ##
+  # The previous position. Only available if the :column option is on.
+
+  attr_accessor :old_pos
+
+  ##
+  # The position of the start of the current line. Only available if the
+  # :column option is on.
+
+  attr_accessor :start_of_current_line_pos
+
+  ##
+  # The current column, starting at 0. Only available if the
+  # :column option is on.
+  def column
+    old_pos - start_of_current_line_pos
+  end
+
 
   ##
   # The current scanner class. Must be overridden in subclasses.
@@ -81,6 +104,8 @@ class RubyLexer
 
   def parse str
     self.ss     = scanner_class.new str
+    self.lineno = 1
+    self.start_of_current_line_pos = 0
     self.state  ||= nil
 
     do_parse
@@ -102,6 +127,8 @@ class RubyLexer
   def location
     [
       (filename || "<input>"),
+      lineno,
+      column,
     ].compact.join(":")
   end
 
@@ -109,7 +136,8 @@ class RubyLexer
   # Lex the next token.
 
   def next_token
-    return process_string if lex_strterm
+    maybe_pop_stack
+    return process_string_or_heredoc if lex_strterm
     self.cmd_state = self.command_start
     self.command_start = false
     self.space_seen    = false # TODO: rename token_seen?
@@ -118,11 +146,17 @@ class RubyLexer
     token = nil
 
     until ss.eos? or token do
+      if ss.check(/\n/) then
+        self.lineno += 1
+        # line starts 1 position after the newline
+        self.start_of_current_line_pos = ss.pos + 1
+      end
+      self.old_pos = ss.pos
       token =
         case state
         when nil then
           case
-          when ss.skip(/[\ \t\r\f\v]/) then
+          when ss.skip(/[\ \t\r\f\v]+/) then
             action { self.space_seen = true; next }
           when text = ss.scan(/\n|\#/) then
             process_newline_or_comment text
@@ -130,15 +164,15 @@ class RubyLexer
             process_brace_close text
           when ss.match?(/\!/) then
             case
-            when is_after_operator? && (ss.skip(/\!\@/)) then
-              action { result EXPR_ARG, :tUBANG, "!@" }
+            when is_after_operator? && (text = ss.scan(/\!\@/)) then
+              action { result EXPR_ARG,   TOKENS[text], text }
             when text = ss.scan(/\![=~]?/) then
               action { result :arg_state, TOKENS[text], text }
             end # group /\!/
           when ss.match?(/\./) then
             case
             when text = ss.scan(/\.\.\.?/) then
-              action { result EXPR_BEG, TOKENS[text], text }
+              process_dots text
             when ss.skip(/\.\d/) then
               action { rb_compile_error "no .<digit> floating literal anymore put 0 before dot" }
             when ss.skip(/\./) then
@@ -160,9 +194,9 @@ class RubyLexer
           when ruby22_label? && (text = ss.scan(/\"#{SIMPLE_STRING}\":/o)) then
             process_label text
           when text = ss.scan(/\"(#{SIMPLE_STRING})\"/o) then
-            action { result EXPR_END, :tSTRING, text[1..-2].gsub(ESC) { unescape $1 } }
+            process_simple_string text
           when text = ss.scan(/\"/) then
-            action { string STR_DQUOTE; result nil, :tSTRING_BEG, text }
+            action { string STR_DQUOTE, '"'; result nil, :tSTRING_BEG, text }
           when text = ss.scan(/\@\@?\d/) then
             action { rb_compile_error "`#{text}` is not allowed as a variable name" }
           when text = ss.scan(/\@\@?#{IDENT_CHAR}+/o) then
@@ -180,8 +214,8 @@ class RubyLexer
             when text = ss.scan(/\:/) then
               process_colon1 text
             end # group /:/
-          when ss.skip(/->/) then
-            action { result EXPR_ENDFN, :tLAMBDA, nil }
+          when text = ss.scan(/->/) then
+            action { result EXPR_ENDFN, :tLAMBDA, text }
           when text = ss.scan(/[+-]/) then
             process_plus_minus text
           when ss.match?(/[+\d]/) then
@@ -211,6 +245,8 @@ class RubyLexer
             process_square_bracket text
           when was_label? && (text = ss.scan(/\'#{SSTRING}\':?/o)) then
             process_label_or_string text
+          when text = ss.scan(/\'/) then
+            action { string STR_SQUOTE, "'"; result nil, :tSTRING_BEG, text }
           when ss.match?(/\|/) then
             case
             when ss.skip(/\|\|\=/) then
@@ -229,11 +265,11 @@ class RubyLexer
             when ss.skip(/\*\*=/) then
               action { result EXPR_BEG, :tOP_ASGN, "**" }
             when ss.skip(/\*\*/) then
-              action { result(:arg_state, space_vs_beginning(:tDSTAR, :tDSTAR, :tPOW), "**") }
+              action { result :arg_state, space_vs_beginning(:tDSTAR, :tDSTAR, :tPOW), "**" }
             when ss.skip(/\*\=/) then
-              action { result(EXPR_BEG, :tOP_ASGN, "*") }
+              action { result EXPR_BEG, :tOP_ASGN, "*" }
             when ss.skip(/\*/) then
-              action { result(:arg_state, space_vs_beginning(:tSTAR, :tSTAR, :tSTAR2), "*") }
+              action { result :arg_state, space_vs_beginning(:tSTAR, :tSTAR, :tSTAR2), "*" }
             end # group /\*/
           when ss.match?(/</) then
             case
@@ -262,24 +298,24 @@ class RubyLexer
           when ss.match?(/\`/) then
             case
             when expr_fname? && (ss.skip(/\`/)) then
-              action { result(EXPR_END, :tBACK_REF2, "`") }
+              action { result EXPR_END, :tBACK_REF2, "`" }
             when expr_dot? && (ss.skip(/\`/)) then
               action { result((cmd_state ? EXPR_CMDARG : EXPR_ARG), :tBACK_REF2, "`") }
             when ss.skip(/\`/) then
-              action { string STR_XQUOTE, '`'; result(nil, :tXSTRING_BEG, "`") }
+              action { string STR_XQUOTE, '`'; result nil, :tXSTRING_BEG, "`" }
             end # group /\`/
           when text = ss.scan(/\?/) then
             process_questionmark text
           when ss.match?(/&/) then
             case
             when ss.skip(/\&\&\=/) then
-              action { result(EXPR_BEG, :tOP_ASGN, "&&") }
+              action { result EXPR_BEG, :tOP_ASGN, "&&" }
             when ss.skip(/\&\&/) then
-              action { result(EXPR_BEG, :tANDOP,   "&&") }
+              action { result EXPR_BEG, :tANDOP,   "&&" }
             when ss.skip(/\&\=/) then
-              action { result(EXPR_BEG, :tOP_ASGN, "&" ) }
+              action { result EXPR_BEG, :tOP_ASGN, "&"  }
             when ss.skip(/\&\./) then
-              action { result(EXPR_DOT, :tLONELY,  "&.") }
+              action { result EXPR_DOT, :tLONELY,  "&." }
             when text = ss.scan(/\&/) then
               process_amper text
             end # group /&/
@@ -288,18 +324,18 @@ class RubyLexer
           when ss.match?(/\^/) then
             case
             when ss.skip(/\^=/) then
-              action { result(EXPR_BEG, :tOP_ASGN, "^") }
+              action { result EXPR_BEG, :tOP_ASGN, "^" }
             when ss.skip(/\^/) then
-              action { result(:arg_state, :tCARET, "^") }
+              action { result :arg_state, :tCARET, "^" }
             end # group /\^/
           when ss.skip(/\;/) then
-            action { self.command_start = true; result(EXPR_BEG, :tSEMI, ";") }
+            action { self.command_start = true; result EXPR_BEG, :tSEMI, ";" }
           when ss.match?(/~/) then
             case
             when is_after_operator? && (ss.skip(/\~@/)) then
-              action { result(:arg_state, :tTILDE, "~") }
+              action { result :arg_state, :tTILDE, "~" }
             when ss.skip(/\~/) then
-              action { result(:arg_state, :tTILDE, "~") }
+              action { result :arg_state, :tTILDE, "~" }
             end # group /~/
           when ss.match?(/\\/) then
             case
@@ -328,16 +364,14 @@ class RubyLexer
               process_nthref text
             when text = ss.scan(/\$0/) then
               process_gvar text
-            when text = ss.scan(/\$[^[:ascii:]]+/) then
+            when text = ss.scan(/\$#{IDENT_CHAR}+/) then
               process_gvar text
-            when text = ss.scan(/\$\W|\$\z/) then
+            when text = ss.scan(/\$\W/) then
               process_gvar_oddity text
-            when text = ss.scan(/\$\w+/) then
-              process_gvar text
             end # group /\$/
           when text = ss.scan(/\_/) then
             process_underscore text
-          when text = ss.scan(/#{IDENT}/o) then
+          when text = ss.scan(/#{IDENT_CHAR}+/o) then
             process_token text
           when ss.skip(/\004|\032|\000|\Z/) then
             action { [RubyLexer::EOF, RubyLexer::EOF] }