brakeman 6.2.0 → 6.2.2.rc1

data/bundle/ruby/3.3.0/gems/racc-1.8.1/lib/racc/statetransitiontable.rb

@@ -0,0 +1,311 @@
+#--
+#
+#
+#
+# Copyright (c) 1999-2006 Minero Aoki
+#
+# This program is free software.
+# You can distribute/modify this program under the same terms of ruby.
+# see the file "COPYING".
+#
+#++
+
+require_relative 'parser'
+
+module Racc
+
+  StateTransitionTable = Struct.new(:action_table,
+                                    :action_check,
+                                    :action_default,
+                                    :action_pointer,
+                                    :goto_table,
+                                    :goto_check,
+                                    :goto_default,
+                                    :goto_pointer,
+                                    :token_table,
+                                    :reduce_table,
+                                    :reduce_n,
+                                    :shift_n,
+                                    :nt_base,
+                                    :token_to_s_table,
+                                    :use_result_var,
+                                    :debug_parser)
+  class StateTransitionTable   # reopen
+    def StateTransitionTable.generate(states)
+      StateTransitionTableGenerator.new(states).generate
+    end
+
+    def initialize(states)
+      super()
+      @states = states
+      @grammar = states.grammar
+      self.use_result_var = true
+      self.debug_parser = true
+    end
+
+    attr_reader :states
+    attr_reader :grammar
+
+    def parser_class
+      ParserClassGenerator.new(@states).generate
+    end
+
+    def token_value_table
+      h = {}
+      token_table().each do |sym, i|
+        h[sym.value] = i
+      end
+      h
+    end
+  end
+
+
+  class StateTransitionTableGenerator
+
+    def initialize(states)
+      @states = states
+      @grammar = states.grammar
+    end
+
+    def generate
+      t = StateTransitionTable.new(@states)
+      gen_action_tables t, @states
+      gen_goto_tables t, @grammar
+      t.token_table = token_table(@grammar)
+      t.reduce_table = reduce_table(@grammar)
+      t.reduce_n = @states.reduce_n
+      t.shift_n = @states.shift_n
+      t.nt_base = @grammar.nonterminal_base
+      t.token_to_s_table = @grammar.symbols.map {|sym| sym.to_s }
+      t
+    end
+
+    def reduce_table(grammar)
+      t = [0, 0, :racc_error]
+      grammar.each_with_index do |rule, idx|
+        next if idx == 0
+        t.push rule.size
+        t.push rule.target.ident
+        t.push(if rule.action.empty?   # and @params.omit_action_call?
+               then :_reduce_none
+               else "_reduce_#{idx}".intern
+               end)
+      end
+      t
+    end
+
+    def token_table(grammar)
+      h = {}
+      grammar.symboltable.terminals.each do |t|
+        h[t] = t.ident
+      end
+      h
+    end
+
+    def gen_action_tables(t, states)
+      t.action_table = yytable  = []
+      t.action_check = yycheck  = []
+      t.action_default = yydefact = []
+      t.action_pointer = yypact   = []
+      e1 = []
+      e2 = []
+      states.each do |state|
+        yydefact.push act2actid(state.defact)
+        if state.action.empty?
+          yypact.push nil
+          next
+        end
+        vector = []
+        state.action.each do |tok, act|
+          vector[tok.ident] = act2actid(act)
+        end
+        addent e1, vector, state.ident, yypact
+      end
+      set_table e1, e2, yytable, yycheck, yypact
+    end
+
+    def gen_goto_tables(t, grammar)
+      t.goto_table   = yytable2  = []
+      t.goto_check   = yycheck2  = []
+      t.goto_pointer = yypgoto   = []
+      t.goto_default = yydefgoto = []
+      e1 = []
+      e2 = []
+      grammar.each_nonterminal do |tok|
+        tmp = []
+
+        # decide default
+        freq = Array.new(@states.size, 0)
+        @states.each do |state|
+          st = state.goto_table[tok]
+          if st
+            st = st.ident
+            freq[st] += 1
+          end
+          tmp[state.ident] = st
+        end
+        max = freq.max
+        if max > 1
+          default = freq.index(max)
+          tmp.map! {|i| default == i ? nil : i }
+        else
+          default = nil
+        end
+        yydefgoto.push default
+
+        # delete default value
+        tmp.pop until tmp.last or tmp.empty?
+        if tmp.compact.empty?
+          # only default
+          yypgoto.push nil
+          next
+        end
+
+        addent e1, tmp, (tok.ident - grammar.nonterminal_base), yypgoto
+      end
+      set_table e1, e2, yytable2, yycheck2, yypgoto
+    end
+
+    def addent(all, arr, chkval, ptr)
+      max = arr.size
+      min = nil
+      arr.each_with_index do |item, idx|
+        if item
+          min ||= idx
+        end
+      end
+      ptr.push(-7777)    # mark
+      arr = arr[min...max]
+      all.push [arr, chkval, mkmapexp(arr), min, ptr.size - 1]
+    end
+
+    n = 2 ** 16
+    begin
+      Regexp.compile("a{#{n}}")
+      RE_DUP_MAX = n
+    rescue RegexpError
+      n /= 2
+      retry
+    end
+
+    def mkmapexp(arr)
+      i = ii = 0
+      as = arr.size
+      map = String.new
+      maxdup = RE_DUP_MAX
+      curr = nil
+      while i < as
+        ii = i + 1
+        if arr[i]
+          ii += 1 while ii < as and arr[ii]
+          curr = '-'
+        else
+          ii += 1 while ii < as and not arr[ii]
+          curr = '.'
+        end
+
+        offset = ii - i
+        if offset == 1
+          map << curr
+        else
+          while offset > maxdup
+            map << "#{curr}{#{maxdup}}"
+            offset -= maxdup
+          end
+          map << "#{curr}{#{offset}}" if offset > 1
+        end
+        i = ii
+      end
+      Regexp.compile(map, Regexp::NOENCODING)
+    end
+
+    def set_table(entries, dummy, tbl, chk, ptr)
+      upper = 0
+      map = '-' * 10240
+
+      # sort long to short
+      entries.sort_by!.with_index {|a,i| [-a[0].size, i] }
+
+      entries.each do |arr, chkval, expr, min, ptri|
+        if upper + arr.size > map.size
+          map << '-' * (arr.size + 1024)
+        end
+        idx = map.index(expr)
+        ptr[ptri] = idx - min
+        arr.each_with_index do |item, i|
+          if item
+            i += idx
+            tbl[i] = item
+            chk[i] = chkval
+            map[i] = ?o
+          end
+        end
+        upper = idx + arr.size
+      end
+    end
+
+    def act2actid(act)
+      case act
+      when Shift  then act.goto_id
+      when Reduce then -act.ruleid
+      when Accept then @states.shift_n
+      when Error  then @states.reduce_n * -1
+      else
+        raise "racc: fatal: wrong act type #{act.class} in action table"
+      end
+    end
+
+  end
+
+
+  class ParserClassGenerator
+
+    def initialize(states)
+      @states = states
+      @grammar = states.grammar
+    end
+
+    def generate
+      table = @states.state_transition_table
+      c = Class.new(::Racc::Parser)
+      c.const_set :Racc_arg, [table.action_table,
+                              table.action_check,
+                              table.action_default,
+                              table.action_pointer,
+                              table.goto_table,
+                              table.goto_check,
+                              table.goto_default,
+                              table.goto_pointer,
+                              table.nt_base,
+                              table.reduce_table,
+                              table.token_value_table,
+                              table.shift_n,
+                              table.reduce_n,
+                              false]
+      c.const_set :Racc_token_to_s_table, table.token_to_s_table
+      c.const_set :Racc_debug_parser, true
+      define_actions c
+      c
+    end
+
+    private
+
+    def define_actions(c)
+      c.module_eval "def _reduce_none(vals, vstack) vals[0] end"
+      @grammar.each do |rule|
+        if rule.action.empty?
+          c.alias_method("_reduce_#{rule.ident}", :_reduce_none)
+        else
+          c.define_method("_racc_action_#{rule.ident}", &rule.action.proc)
+          c.module_eval(<<-End, __FILE__, __LINE__ + 1)
+            def _reduce_#{rule.ident}(vals, vstack)
+              _racc_action_#{rule.ident}(*vals)
+            end
+          End
+        end
+      end
+    end
+
+  end
+
+end   # module Racc

data/bundle/ruby/3.3.0/gems/racc-1.8.1/lib/racc/static.rb

@@ -0,0 +1,5 @@
+require_relative '../racc'
+require_relative 'parser'
+require_relative 'grammarfileparser'
+require_relative 'parserfilegenerator'
+require_relative 'logfilegenerator'

data/bundle/ruby/3.3.0/gems/racc-1.8.1/lib/racc.rb

@@ -0,0 +1,6 @@
+require_relative 'racc/compat'
+require_relative 'racc/debugflags'
+require_relative 'racc/grammar'
+require_relative 'racc/state'
+require_relative 'racc/exception'
+require_relative 'racc/info'

data/bundle/ruby/{3.1.0/gems/reline-0.5.9 → 3.3.0/gems/reline-0.5.10}/lib/reline/config.rb

@@ -29,6 +29,17 @@ class Reline::Config
   attr_accessor :autocompletion
 
   def initialize
+    reset_variables
+  end
+
+  def reset
+    if editing_mode_is?(:vi_command)
+      @editing_mode_label = :vi_insert
+    end
+    @oneshot_key_bindings.clear
+  end
+
+  def reset_variables
     @additional_key_bindings = { # from inputrc
       emacs: Reline::KeyActor::Base.new,
       vi_insert: Reline::KeyActor::Base.new,
@@ -51,16 +62,11 @@ class Reline::Config
     @keyseq_timeout = 500
     @test_mode = false
     @autocompletion = false
-    @convert_meta = true if seven_bit_encoding?(Reline::IOGate.encoding)
+    @convert_meta = seven_bit_encoding?(Reline::IOGate.encoding)
     @loaded = false
     @enable_bracketed_paste = true
-  end
-
-  def reset
-    if editing_mode_is?(:vi_command)
-      @editing_mode_label = :vi_insert
-    end
-    @oneshot_key_bindings.clear
+    @show_mode_in_prompt = false
+    @default_inputrc_path = nil
   end
 
   def editing_mode
@@ -245,22 +251,6 @@ class Reline::Config
       rescue ArgumentError
         @history_size = 500
       end
-    when 'bell-style'
-      @bell_style =
-        case value
-        when 'none', 'off'
-          :none
-        when 'audible', 'on'
-          :audible
-        when 'visible'
-          :visible
-        else
-          :audible
-        end
-    when 'comment-begin'
-      @comment_begin = value.dup
-    when 'completion-query-items'
-      @completion_query_items = value.to_i
     when 'isearch-terminators'
       @isearch_terminators = retrieve_string(raw_value)
     when 'editing-mode'
@@ -376,6 +366,11 @@ class Reline::Config
     ret
   end
 
+  def reload
+    reset_variables
+    read
+  end
+
   private def seven_bit_encoding?(encoding)
     encoding == Encoding::US_ASCII
   end

data/bundle/ruby/{3.1.0/gems/reline-0.5.9 → 3.3.0/gems/reline-0.5.10}/lib/reline/face.rb

@@ -107,7 +107,7 @@ class Reline::Face
 
     def sgr_rgb_256color(key, value)
       # 256 colors are
-      # 0..15: standard colors, hight intensity colors
+      # 0..15: standard colors, high intensity colors
       # 16..232: 216 colors (R, G, B each 6 steps)
       # 233..255: grayscale colors (24 steps)
       # This methods converts rgb_expression to 216 colors

data/bundle/ruby/{3.1.0/gems/reline-0.5.9 → 3.3.0/gems/reline-0.5.10}/lib/reline/io/ansi.rb

@@ -347,6 +347,13 @@ class Reline::ANSI < Reline::IO
 
   def set_winch_handler(&handler)
     @old_winch_handler = Signal.trap('WINCH', &handler)
+    @old_cont_handler = Signal.trap('CONT') do
+      @input.raw!(intr: true) if @input.tty?
+      # Rerender the screen. Note that screen size might be changed while suspended.
+      handler.call
+    end
+  rescue ArgumentError
+    # Signal.trap may raise an ArgumentError if the platform doesn't support the signal.
   end
 
   def prep
@@ -360,5 +367,6 @@ class Reline::ANSI < Reline::IO
     # Disable bracketed paste
     @output.write "\e[?2004l" if Reline.core.config.enable_bracketed_paste && both_tty?
     Signal.trap('WINCH', @old_winch_handler) if @old_winch_handler
+    Signal.trap('CONT', @old_cont_handler) if @old_cont_handler
   end
 end

data/bundle/ruby/{3.1.0/gems/reline-0.5.9 → 3.3.0/gems/reline-0.5.10}/lib/reline/io/windows.rb

@@ -159,14 +159,24 @@ class Reline::Windows < Reline::IO
   FILE_NAME_INFO = 2
   ENABLE_VIRTUAL_TERMINAL_PROCESSING = 4
 
+  # Calling Win32API with console handle is reported to fail after executing some external command.
+  # We need to refresh console handle and retry the call again.
+  private def call_with_console_handle(win32func, *args)
+    val = win32func.call(@hConsoleHandle, *args)
+    return val if val != 0
+
+    @hConsoleHandle = @GetStdHandle.call(STD_OUTPUT_HANDLE)
+    win32func.call(@hConsoleHandle, *args)
+  end
+
   private def getconsolemode
     mode = "\000\000\000\000"
-    @GetConsoleMode.call(@hConsoleHandle, mode)
+    call_with_console_handle(@GetConsoleMode, mode)
     mode.unpack1('L')
   end
 
   private def setconsolemode(mode)
-    @SetConsoleMode.call(@hConsoleHandle, mode)
+    call_with_console_handle(@SetConsoleMode, mode)
   end
 
   #if @legacy_console
@@ -334,7 +344,7 @@ class Reline::Windows < Reline::IO
     # [18,2] dwMaximumWindowSize.X
     # [20,2] dwMaximumWindowSize.Y
     csbi = 0.chr * 22
-    return if @GetConsoleScreenBufferInfo.call(@hConsoleHandle, csbi) == 0
+    return if call_with_console_handle(@GetConsoleScreenBufferInfo, csbi) == 0
     csbi
   end
 
@@ -355,14 +365,14 @@ class Reline::Windows < Reline::IO
   end
 
   def move_cursor_column(val)
-    @SetConsoleCursorPosition.call(@hConsoleHandle, cursor_pos.y * 65536 + val)
+    call_with_console_handle(@SetConsoleCursorPosition, cursor_pos.y * 65536 + val)
   end
 
   def move_cursor_up(val)
     if val > 0
       y = cursor_pos.y - val
       y = 0 if y < 0
-      @SetConsoleCursorPosition.call(@hConsoleHandle, y * 65536 + cursor_pos.x)
+      call_with_console_handle(@SetConsoleCursorPosition, y * 65536 + cursor_pos.x)
     elsif val < 0
       move_cursor_down(-val)
     end
@@ -374,7 +384,7 @@ class Reline::Windows < Reline::IO
       screen_height = get_screen_size.first
       y = cursor_pos.y + val
       y = screen_height - 1 if y > (screen_height - 1)
-      @SetConsoleCursorPosition.call(@hConsoleHandle, (cursor_pos.y + val) * 65536 + cursor_pos.x)
+      call_with_console_handle(@SetConsoleCursorPosition, (cursor_pos.y + val) * 65536 + cursor_pos.x)
     elsif val < 0
       move_cursor_up(-val)
     end
@@ -385,8 +395,8 @@ class Reline::Windows < Reline::IO
     attributes = csbi[8, 2].unpack1('S')
     cursor = csbi[4, 4].unpack1('L')
     written = 0.chr * 4
-    @FillConsoleOutputCharacter.call(@hConsoleHandle, 0x20, get_screen_size.last - cursor_pos.x, cursor, written)
-    @FillConsoleOutputAttribute.call(@hConsoleHandle, attributes, get_screen_size.last - cursor_pos.x, cursor, written)
+    call_with_console_handle(@FillConsoleOutputCharacter, 0x20, get_screen_size.last - cursor_pos.x, cursor, written)
+    call_with_console_handle(@FillConsoleOutputAttribute, attributes, get_screen_size.last - cursor_pos.x, cursor, written)
   end
 
   def scroll_down(val)
@@ -404,7 +414,7 @@ class Reline::Windows < Reline::IO
       scroll_rectangle = [0, val, buffer_width, buffer_lines - val].pack('s4')
       destination_origin = 0 # y * 65536 + x
       fill = [' '.ord, attributes].pack('SS')
-      @ScrollConsoleScreenBuffer.call(@hConsoleHandle, scroll_rectangle, nil, destination_origin, fill)
+      call_with_console_handle(@ScrollConsoleScreenBuffer, scroll_rectangle, nil, destination_origin, fill)
     else
       origin_x = x + 1
       origin_y = y - window_top + 1
@@ -423,9 +433,9 @@ class Reline::Windows < Reline::IO
       fill_length = buffer_width * (window_bottom - window_top + 1)
       screen_topleft = window_top * 65536
       written = 0.chr * 4
-      @FillConsoleOutputCharacter.call(@hConsoleHandle, 0x20, fill_length, screen_topleft, written)
-      @FillConsoleOutputAttribute.call(@hConsoleHandle, attributes, fill_length, screen_topleft, written)
-      @SetConsoleCursorPosition.call(@hConsoleHandle, screen_topleft)
+      call_with_console_handle(@FillConsoleOutputCharacter, 0x20, fill_length, screen_topleft, written)
+      call_with_console_handle(@FillConsoleOutputAttribute, attributes, fill_length, screen_topleft, written)
+      call_with_console_handle(@SetConsoleCursorPosition, screen_topleft)
     else
       @output.write "\e[2J" "\e[H"
     end
@@ -439,14 +449,14 @@ class Reline::Windows < Reline::IO
     size = 100
     visible = 0 # 0 means false
     cursor_info = [size, visible].pack('Li')
-    @SetConsoleCursorInfo.call(@hConsoleHandle, cursor_info)
+    call_with_console_handle(@SetConsoleCursorInfo, cursor_info)
   end
 
   def show_cursor
     size = 100
     visible = 1 # 1 means true
     cursor_info = [size, visible].pack('Li')
-    @SetConsoleCursorInfo.call(@hConsoleHandle, cursor_info)
+    call_with_console_handle(@SetConsoleCursorInfo, cursor_info)
   end
 
   def set_winch_handler(&handler)