brakeman 6.2.2 → 8.0.4

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

@@ -2,18 +2,6 @@ require 'io/console'
 require 'io/wait'
 
 class Reline::ANSI < Reline::IO
-  CAPNAME_KEY_BINDINGS = {
-    'khome' => :ed_move_to_beg,
-    'kend'  => :ed_move_to_end,
-    'kdch1' => :key_delete,
-    'kpp' => :ed_search_prev_history,
-    'knp' => :ed_search_next_history,
-    'kcuu1' => :ed_prev_history,
-    'kcud1' => :ed_next_history,
-    'kcuf1' => :ed_next_char,
-    'kcub1' => :ed_prev_char,
-  }
-
   ANSI_CURSOR_KEY_BINDINGS = {
     # Up
     'A' => [:ed_prev_history, {}],
@@ -29,29 +17,27 @@ class Reline::ANSI < Reline::IO
     'H' => [:ed_move_to_beg, {}],
   }
 
-  if Reline::Terminfo.enabled?
-    Reline::Terminfo.setupterm(0, 2)
-  end
+  attr_writer :input, :output
 
   def initialize
     @input = STDIN
     @output = STDOUT
     @buf = []
+    @output_buffer = nil
     @old_winch_handler = nil
   end
 
   def encoding
+    @input.external_encoding || Encoding.default_external
+  rescue IOError
+    # STDIN.external_encoding raises IOError in Ruby <= 3.0 when STDIN is closed
     Encoding.default_external
   end
 
-  def set_default_key_bindings(config, allow_terminfo: true)
+  def set_default_key_bindings(config)
     set_bracketed_paste_key_bindings(config)
     set_default_key_bindings_ansi_cursor(config)
-    if allow_terminfo && Reline::Terminfo.enabled?
-      set_default_key_bindings_terminfo(config)
-    else
-      set_default_key_bindings_comprehensive_list(config)
-    end
+    set_default_key_bindings_comprehensive_list(config)
     {
       [27, 91, 90] => :completion_journey_up, # S-Tab
     }.each_pair do |key, func|
@@ -75,7 +61,10 @@ class Reline::ANSI < Reline::IO
 
   def set_default_key_bindings_ansi_cursor(config)
     ANSI_CURSOR_KEY_BINDINGS.each do |char, (default_func, modifiers)|
-      bindings = [["\e[#{char}", default_func]] # CSI + char
+      bindings = [
+        ["\e[#{char}", default_func], # CSI + char
+        ["\eO#{char}", default_func] # SS3 + char, application cursor key mode
+      ]
       if modifiers[:ctrl]
         # CSI + ctrl_key_modifier + char
         bindings << ["\e[1;5#{char}", modifiers[:ctrl]]
@@ -95,23 +84,6 @@ class Reline::ANSI < Reline::IO
     end
   end
 
-  def set_default_key_bindings_terminfo(config)
-    key_bindings = CAPNAME_KEY_BINDINGS.map do |capname, key_binding|
-      begin
-        key_code = Reline::Terminfo.tigetstr(capname)
-        [ key_code.bytes, key_binding ]
-      rescue Reline::Terminfo::TerminfoError
-        # capname is undefined
-      end
-    end.compact.to_h
-
-    key_bindings.each_pair do |key, func|
-      config.add_default_key_binding_by_keymap(:emacs, key, func)
-      config.add_default_key_binding_by_keymap(:vi_insert, key, func)
-      config.add_default_key_binding_by_keymap(:vi_command, key, func)
-    end
-  end
-
   def set_default_key_bindings_comprehensive_list(config)
     {
       # xterm
@@ -123,27 +95,9 @@ class Reline::ANSI < Reline::IO
       [27, 91, 49, 126] => :ed_move_to_beg, # Home
       [27, 91, 52, 126] => :ed_move_to_end, # End
 
-      # KDE
-      # Del is 0x08
-      [27, 71, 65] => :ed_prev_history,     # ↑
-      [27, 71, 66] => :ed_next_history,     # ↓
-      [27, 71, 67] => :ed_next_char,        # →
-      [27, 71, 68] => :ed_prev_char,        # ←
-
       # urxvt / exoterm
       [27, 91, 55, 126] => :ed_move_to_beg, # Home
       [27, 91, 56, 126] => :ed_move_to_end, # End
-
-      # GNOME
-      [27, 79, 72] => :ed_move_to_beg,      # Home
-      [27, 79, 70] => :ed_move_to_end,      # End
-      # Del is 0x08
-      # Arrow keys are the same of KDE
-
-      [27, 79, 65] => :ed_prev_history,     # ↑
-      [27, 79, 66] => :ed_next_history,     # ↓
-      [27, 79, 67] => :ed_next_char,        # →
-      [27, 79, 68] => :ed_prev_char,        # ←
     }.each_pair do |key, func|
       config.add_default_key_binding_by_keymap(:emacs, key, func)
       config.add_default_key_binding_by_keymap(:vi_insert, key, func)
@@ -151,14 +105,6 @@ class Reline::ANSI < Reline::IO
     end
   end
 
-  def input=(val)
-    @input = val
-  end
-
-  def output=(val)
-    @output = val
-  end
-
   def with_raw_input
     if @input.tty?
       @input.raw(intr: true) { yield }
@@ -178,6 +124,10 @@ class Reline::ANSI < Reline::IO
       Reline.core.line_editor.handle_signal
     end
     c = @input.getbyte
+
+    # When "Escape non-ASCII Input with Control-V" is enabled in macOS Terminal.app,
+    # all non-ascii bytes are automatically escaped with `C-v`.
+    # "\xE3\x81\x82" (U+3042) becomes "\x16\xE3\x16\x81\x16\x82".
     (c == 0x16 && @input.tty? && @input.raw(min: 0, time: 0, &:getbyte)) || c
   rescue Errno::EIO
     # Maybe the I/O has been closed.
@@ -217,80 +167,74 @@ class Reline::ANSI < Reline::IO
     @buf.unshift(c)
   end
 
-  def retrieve_keybuffer
-    begin
-      return unless @input.wait_readable(0.001)
-      str = @input.read_nonblock(1024)
-      str.bytes.each do |c|
-        @buf.push(c)
-      end
-    rescue EOFError
-    end
-  end
-
   def get_screen_size
     s = @input.winsize
     return s if s[0] > 0 && s[1] > 0
     s = [ENV["LINES"].to_i, ENV["COLUMNS"].to_i]
     return s if s[0] > 0 && s[1] > 0
     [24, 80]
-  rescue Errno::ENOTTY, Errno::ENODEV
+  rescue SystemCallError
     [24, 80]
   end
 
   def set_screen_size(rows, columns)
     @input.winsize = [rows, columns]
     self
-  rescue Errno::ENOTTY, Errno::ENODEV
+  rescue SystemCallError
     self
   end
 
-  def cursor_pos
-    if both_tty?
-      res = +''
-      m = nil
-      @input.raw do |stdin|
-        @output << "\e[6n"
-        @output.flush
-        loop do
-          c = stdin.getc
-          next if c.nil?
-          res << c
-          m = res.match(/\e\[(?<row>\d+);(?<column>\d+)R/)
-          break if m
-        end
-        (m.pre_match + m.post_match).chars.reverse_each do |ch|
-          stdin.ungetc ch
+  private def cursor_pos_internal(timeout:)
+    match = nil
+    @input.raw do |stdin|
+      @output << "\e[6n"
+      @output.flush
+      timeout_at = Time.now + timeout
+      buf = +''
+      while (wait = timeout_at - Time.now) > 0 && stdin.wait_readable(wait)
+        buf << stdin.readpartial(1024)
+        if (match = buf.match(/\e\[(?<row>\d+);(?<column>\d+)R/))
+          buf = match.pre_match + match.post_match
+          break
         end
       end
-      column = m[:column].to_i - 1
-      row = m[:row].to_i - 1
-    else
-      begin
-        buf = @output.pread(@output.pos, 0)
-        row = buf.count("\n")
-        column = buf.rindex("\n") ? (buf.size - buf.rindex("\n")) - 1 : 0
-      rescue Errno::ESPIPE, IOError
-        # Just returns column 1 for ambiguous width because this I/O is not
-        # tty and can't seek.
-        row = 0
-        column = 1
-      end
+      @buf.concat buf.bytes
     end
-    Reline::CursorPos.new(column, row)
+    [match[:column].to_i - 1, match[:row].to_i - 1] if match
+  end
+
+  def cursor_pos
+    col, row = cursor_pos_internal(timeout: 0.5) if both_tty?
+    Reline::CursorPos.new(col || 0, row || 0)
   end
 
   def both_tty?
     @input.tty? && @output.tty?
   end
 
+  def write(string)
+    if @output_buffer
+      @output_buffer << string
+    else
+      @output.write(string)
+    end
+  end
+
+  def buffered_output
+    @output_buffer = +''
+    yield
+    @output.write(@output_buffer)
+  ensure
+    @output_buffer = nil
+  end
+
   def move_cursor_column(x)
-    @output.write "\e[#{x + 1}G"
+    write "\e[#{x + 1}G"
   end
 
   def move_cursor_up(x)
     if x > 0
-      @output.write "\e[#{x}A"
+      write "\e[#{x}A"
     elsif x < 0
       move_cursor_down(-x)
     end
@@ -298,38 +242,22 @@ class Reline::ANSI < Reline::IO
 
   def move_cursor_down(x)
     if x > 0
-      @output.write "\e[#{x}B"
+      write "\e[#{x}B"
     elsif x < 0
       move_cursor_up(-x)
     end
   end
 
   def hide_cursor
-    seq = "\e[?25l"
-    if Reline::Terminfo.enabled? && Reline::Terminfo.term_supported?
-      begin
-        seq = Reline::Terminfo.tigetstr('civis')
-      rescue Reline::Terminfo::TerminfoError
-        # civis is undefined
-      end
-    end
-    @output.write seq
+    write "\e[?25l"
   end
 
   def show_cursor
-    seq = "\e[?25h"
-    if Reline::Terminfo.enabled? && Reline::Terminfo.term_supported?
-      begin
-        seq = Reline::Terminfo.tigetstr('cnorm')
-      rescue Reline::Terminfo::TerminfoError
-        # cnorm is undefined
-      end
-    end
-    @output.write seq
+    write "\e[?25h"
   end
 
   def erase_after_cursor
-    @output.write "\e[K"
+    write "\e[K"
   end
 
   # This only works when the cursor is at the bottom of the scroll range
@@ -337,35 +265,45 @@ class Reline::ANSI < Reline::IO
   def scroll_down(x)
     return if x.zero?
     # We use `\n` instead of CSI + S because CSI + S would cause https://github.com/ruby/reline/issues/576
-    @output.write "\n" * x
+    write "\n" * x
   end
 
   def clear_screen
-    @output.write "\e[2J"
-    @output.write "\e[1;1H"
+    write "\e[2J"
+    write "\e[1;1H"
   end
 
   def set_winch_handler(&handler)
-    @old_winch_handler = Signal.trap('WINCH', &handler)
-    @old_cont_handler = Signal.trap('CONT') do
+    @old_winch_handler = Signal.trap('WINCH') do |arg|
+      handler.call
+      @old_winch_handler.call(arg) if @old_winch_handler.respond_to?(:call)
+    end
+    @old_cont_handler = Signal.trap('CONT') do |arg|
       @input.raw!(intr: true) if @input.tty?
       # Rerender the screen. Note that screen size might be changed while suspended.
       handler.call
+      @old_cont_handler.call(arg) if @old_cont_handler.respond_to?(:call)
     end
   rescue ArgumentError
     # Signal.trap may raise an ArgumentError if the platform doesn't support the signal.
   end
 
+  def read_single_char(timeout_second)
+    # Disable intr to read `C-c` `C-z` `C-\` for quoted insert
+    @input.raw(intr: false) do
+      super
+    end
+  end
+
   def prep
     # Enable bracketed paste
-    @output.write "\e[?2004h" if Reline.core.config.enable_bracketed_paste && both_tty?
-    retrieve_keybuffer
+    write "\e[?2004h" if Reline.core.config.enable_bracketed_paste && both_tty?
     nil
   end
 
   def deprep(otio)
     # Disable bracketed paste
-    @output.write "\e[?2004l" if Reline.core.config.enable_bracketed_paste && both_tty?
+    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

data/bundle/ruby/{3.1.0/gems/reline-0.5.10 → 3.2.0/gems/reline-0.6.3}/lib/reline/io/dumb.rb

@@ -3,8 +3,11 @@ require 'io/wait'
 class Reline::Dumb < Reline::IO
   RESET_COLOR = '' # Do not send color reset sequence
 
+  attr_writer :output
+
   def initialize(encoding: nil)
     @input = STDIN
+    @output = STDOUT
     @buf = []
     @pasting = false
     @encoding = encoding
@@ -21,8 +24,11 @@ class Reline::Dumb < Reline::IO
     elsif RUBY_PLATFORM =~ /mswin|mingw/
       Encoding::UTF_8
     else
-      Encoding::default_external
+      @input.external_encoding || Encoding.default_external
     end
+  rescue IOError
+    # STDIN.external_encoding raises IOError in Ruby <= 3.0 when STDIN is closed
+    Encoding.default_external
   end
 
   def set_default_key_bindings(_)
@@ -36,6 +42,14 @@ class Reline::Dumb < Reline::IO
     yield
   end
 
+  def write(string)
+    @output.write(string)
+  end
+
+  def buffered_output
+    yield
+  end
+
   def getc(_timeout_second)
     unless @buf.empty?
       return @buf.shift
@@ -60,7 +74,7 @@ class Reline::Dumb < Reline::IO
   end
 
   def cursor_pos
-    Reline::CursorPos.new(1, 1)
+    Reline::CursorPos.new(0, 0)
   end
 
   def hide_cursor

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

@@ -1,6 +1,9 @@
 require 'fiddle/import'
 
 class Reline::Windows < Reline::IO
+
+  attr_writer :output
+
   def initialize
     @input_buf = []
     @output_buf = []
@@ -52,7 +55,6 @@ class Reline::Windows < Reline::IO
       [224, 83] => :key_delete,      # Del
       [224, 71] => :ed_move_to_beg,  # Home
       [224, 79] => :ed_move_to_end,  # End
-      [  0, 41] => :ed_unassigned,   # input method on/off
       [  0, 72] => :ed_prev_history, # ↑
       [  0, 80] => :ed_next_history, # ↓
       [  0, 77] => :ed_next_char,    # →
@@ -157,6 +159,7 @@ class Reline::Windows < Reline::IO
   STD_OUTPUT_HANDLE = -11
   FILE_TYPE_PIPE = 0x0003
   FILE_NAME_INFO = 2
+  ENABLE_WRAP_AT_EOL_OUTPUT = 2
   ENABLE_VIRTUAL_TERMINAL_PROCESSING = 4
 
   # Calling Win32API with console handle is reported to fail after executing some external command.
@@ -170,7 +173,7 @@ class Reline::Windows < Reline::IO
   end
 
   private def getconsolemode
-    mode = "\000\000\000\000"
+    mode = +"\0\0\0\0"
     call_with_console_handle(@GetConsoleMode, mode)
     mode.unpack1('L')
   end
@@ -252,7 +255,7 @@ class Reline::Windows < Reline::IO
 
     key = KeyEventRecord.new(virtual_key_code, char_code, control_key_state)
 
-    match = KEY_MAP.find { |args,| key.matches?(**args) }
+    match = KEY_MAP.find { |args,| key.match?(**args) }
     unless match.nil?
       @output_buf.concat(match.last)
       return
@@ -307,6 +310,14 @@ class Reline::Windows < Reline::IO
     yield
   end
 
+  def write(string)
+    @output.write(string)
+  end
+
+  def buffered_output
+    yield
+  end
+
   def getc(_timeout_second)
     check_input_event
     @output_buf.shift
@@ -344,35 +355,38 @@ class Reline::Windows < Reline::IO
     # [18,2] dwMaximumWindowSize.X
     # [20,2] dwMaximumWindowSize.Y
     csbi = 0.chr * 22
-    return if call_with_console_handle(@GetConsoleScreenBufferInfo, csbi) == 0
-    csbi
+    if call_with_console_handle(@GetConsoleScreenBufferInfo, csbi) != 0
+      # returns [width, height, x, y, attributes, left, top, right, bottom]
+      csbi.unpack("s9")
+    else
+      return nil
+    end
   end
 
+  ALTERNATIVE_CSBI = [80, 24, 0, 0, 7, 0, 0, 79, 23].freeze
+
   def get_screen_size
-    unless csbi = get_console_screen_buffer_info
-      return [1, 1]
-    end
-    csbi[0, 4].unpack('SS').reverse
+    width, _, _, _, _, _, top, _, bottom = get_console_screen_buffer_info || ALTERNATIVE_CSBI
+    [bottom - top + 1, width]
   end
 
   def cursor_pos
-    unless csbi = get_console_screen_buffer_info
-      return Reline::CursorPos.new(0, 0)
-    end
-    x = csbi[4, 2].unpack1('s')
-    y = csbi[6, 2].unpack1('s')
-    Reline::CursorPos.new(x, y)
+    _, _, x, y, _, _, top, = get_console_screen_buffer_info || ALTERNATIVE_CSBI
+    Reline::CursorPos.new(x, y - top)
   end
 
   def move_cursor_column(val)
-    call_with_console_handle(@SetConsoleCursorPosition, cursor_pos.y * 65536 + val)
+    _, _, _, y, = get_console_screen_buffer_info
+    call_with_console_handle(@SetConsoleCursorPosition, y * 65536 + val) if y
   end
 
   def move_cursor_up(val)
     if val > 0
-      y = cursor_pos.y - val
+      _, _, x, y, _, _, top, = get_console_screen_buffer_info
+      return unless y
+      y = (y - top) - val
       y = 0 if y < 0
-      call_with_console_handle(@SetConsoleCursorPosition, y * 65536 + cursor_pos.x)
+      call_with_console_handle(@SetConsoleCursorPosition, (y + top) * 65536 + x)
     elsif val < 0
       move_cursor_down(-val)
     end
@@ -380,58 +394,39 @@ class Reline::Windows < Reline::IO
 
   def move_cursor_down(val)
     if val > 0
-      return unless csbi = get_console_screen_buffer_info
-      screen_height = get_screen_size.first
-      y = cursor_pos.y + val
-      y = screen_height - 1 if y > (screen_height - 1)
-      call_with_console_handle(@SetConsoleCursorPosition, (cursor_pos.y + val) * 65536 + cursor_pos.x)
+      _, _, x, y, _, _, top, _, bottom = get_console_screen_buffer_info
+      return unless y
+      screen_height = bottom - top
+      y = (y - top) + val
+      y = screen_height if y > screen_height
+      call_with_console_handle(@SetConsoleCursorPosition, (y + top) * 65536 + x)
     elsif val < 0
       move_cursor_up(-val)
     end
   end
 
   def erase_after_cursor
-    return unless csbi = get_console_screen_buffer_info
-    attributes = csbi[8, 2].unpack1('S')
-    cursor = csbi[4, 4].unpack1('L')
+    width, _, x, y, attributes, = get_console_screen_buffer_info
+    return unless x
     written = 0.chr * 4
-    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)
-    return if val < 0
-    return unless csbi = get_console_screen_buffer_info
-    buffer_width, buffer_lines, x, y, attributes, window_left, window_top, window_bottom = csbi.unpack('ssssSssx2s')
-    screen_height = window_bottom - window_top + 1
-    val = screen_height if val > screen_height
-
-    if @legacy_console || window_left != 0
-      # unless ENABLE_VIRTUAL_TERMINAL,
-      # if srWindow.Left != 0 then it's conhost.exe hosted console
-      # and puts "\n" causes horizontal scroll. its glitch.
-      # FYI irb write from culumn 1, so this gives no gain.
-      scroll_rectangle = [0, val, buffer_width, buffer_lines - val].pack('s4')
-      destination_origin = 0 # y * 65536 + x
-      fill = [' '.ord, attributes].pack('SS')
-      call_with_console_handle(@ScrollConsoleScreenBuffer, scroll_rectangle, nil, destination_origin, fill)
-    else
-      origin_x = x + 1
-      origin_y = y - window_top + 1
-      @output.write [
-        (origin_y != screen_height) ? "\e[#{screen_height};H" : nil,
-        "\n" * val,
-        (origin_y != screen_height or !x.zero?) ? "\e[#{origin_y};#{origin_x}H" : nil
-      ].join
-    end
+    call_with_console_handle(@FillConsoleOutputCharacter, 0x20, width - x, y * 65536 + x, written)
+    call_with_console_handle(@FillConsoleOutputAttribute, attributes, width - x, y * 65536 + x, written)
+  end
+
+  # This only works when the cursor is at the bottom of the scroll range
+  # For more details, see https://github.com/ruby/reline/pull/577#issuecomment-1646679623
+  def scroll_down(x)
+    return if x.zero?
+    # We use `\n` instead of CSI + S because CSI + S would cause https://github.com/ruby/reline/issues/576
+    @output.write "\n" * x
   end
 
   def clear_screen
     if @legacy_console
-      return unless csbi = get_console_screen_buffer_info
-      buffer_width, _buffer_lines, attributes, window_top, window_bottom = csbi.unpack('ss@8S@12sx2s')
-      fill_length = buffer_width * (window_bottom - window_top + 1)
-      screen_topleft = window_top * 65536
+      width, _, _, _, attributes, _, top, _, bottom = get_console_screen_buffer_info
+      return unless width
+      fill_length = width * (bottom - top + 1)
+      screen_topleft = top * 65536
       written = 0.chr * 4
       call_with_console_handle(@FillConsoleOutputCharacter, 0x20, fill_length, screen_topleft, written)
       call_with_console_handle(@FillConsoleOutputAttribute, attributes, fill_length, screen_topleft, written)
@@ -472,6 +467,28 @@ class Reline::Windows < Reline::IO
     # do nothing
   end
 
+  def disable_auto_linewrap(setting = true, &block)
+    mode = getconsolemode
+    if 0 == (mode & ENABLE_VIRTUAL_TERMINAL_PROCESSING)
+      if block
+        begin
+          setconsolemode(mode & ~ENABLE_WRAP_AT_EOL_OUTPUT)
+          block.call
+        ensure
+          setconsolemode(mode | ENABLE_WRAP_AT_EOL_OUTPUT)
+        end
+      else
+        if setting
+          setconsolemode(mode & ~ENABLE_WRAP_AT_EOL_OUTPUT)
+        else
+          setconsolemode(mode | ENABLE_WRAP_AT_EOL_OUTPUT)
+        end
+      end
+    else
+      block.call if block
+    end
+  end
+
   class KeyEventRecord
 
     attr_reader :virtual_key_code, :char_code, :control_key_state, :control_keys
@@ -501,7 +518,7 @@ class Reline::Windows < Reline::IO
     # Verifies if the arguments match with this key event.
     # Nil arguments are ignored, but at least one must be passed as non-nil.
     # To verify that no control keys were pressed, pass an empty array: `control_keys: []`.
-    def matches?(control_keys: nil, virtual_key_code: nil, char_code: nil)
+    def match?(control_keys: nil, virtual_key_code: nil, char_code: nil)
       raise ArgumentError, 'No argument was passed to match key event' if control_keys.nil? && virtual_key_code.nil? && char_code.nil?
 
       (control_keys.nil? || [*control_keys].sort == @control_keys) &&

data/bundle/ruby/{3.1.0/gems/reline-0.5.10 → 3.2.0/gems/reline-0.6.3}/lib/reline/io.rb

@@ -35,6 +35,20 @@ module Reline
     def reset_color_sequence
       self.class::RESET_COLOR
     end
+
+    # Read a single encoding valid character from the input.
+    def read_single_char(timeout_second)
+      buffer = String.new(encoding: Encoding::ASCII_8BIT)
+      loop do
+        timeout = buffer.empty? ? Float::INFINITY : timeout_second
+        c = getc(timeout)
+        return unless c
+
+        buffer << c
+        encoded = buffer.dup.force_encoding(encoding)
+        return encoded if encoded.valid_encoding?
+      end
+    end
   end
 end
 

data/bundle/ruby/{3.1.0/gems/reline-0.5.10 → 3.2.0/gems/reline-0.6.3}/lib/reline/key_actor/base.rb

@@ -1,12 +1,18 @@
 class Reline::KeyActor::Base
-  def initialize(mapping = [])
-    @mapping = mapping
+  def initialize(mappings = nil)
     @matching_bytes = {}
     @key_bindings = {}
+    add_mappings(mappings) if mappings
   end
 
-  def get_method(key)
-    @mapping[key]
+  def add_mappings(mappings)
+    add([27], :ed_ignore)
+    128.times do |key|
+      func = mappings[key]
+      meta_func = mappings[key | 0b10000000]
+      add([key], func) if func
+      add([27, key], meta_func) if meta_func
+    end
   end
 
   def add(key, func)