reline 0.5.9 → 0.5.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 28ee53a9963a33e9eb1159bea507695d94cc4f67b05ce005175808b7ec2d5175
-  data.tar.gz: c165de2edcc223bc4e3e149208fe29994063445ea0cf02b93658010a245df5e4
+  metadata.gz: d2e17ec5d6de83746c38c5e0764f7fa1ecda40f01c18b9e8cdf769e4bf2a155e
+  data.tar.gz: 7ce06466fae4c8115bb507141998d322595b9e924dfc1ad3001871265088a680
 SHA512:
-  metadata.gz: af0f93e54d3a414c63dfb369746f00e8fa9cac609c646c0a48ad5f87275e7b6f5c88c47d4c30218075d3774fd41ba7978f49a0ffbfa070ee42921ba0e500c06e
-  data.tar.gz: 5b0a45b7ae2cfb0e23c9d3b4a863e381f4d9ba5d6298f864c261e408cb5c366031d6137d623d0d46e3729b7bbe086fc5da5c5e636163bce230ae0f297441e016
+  metadata.gz: 31e90ffea6ac235aad5c2c243fbd41163142f94e044ed9f4980860263fab97154857483755dcacd259fa9b578b1c29be5b878cd7f883f18e7b92380cb5865ef3
+  data.tar.gz: 54b91a893c536b3e6b5c984c0fc2b053b8978ab586ae361446fb603c4eecfb0240a99c45b25e4996ff58d9ef15fa4e33bab5cef9cb4aef3dc7eab85998af3711

data/lib/reline/config.rb

@@ -1,7 +1,7 @@
 class Reline::Config
   attr_reader :test_mode
 
-  KEYSEQ_PATTERN = /\\(?:C|Control)-[A-Za-z_]|\\(?:M|Meta)-[0-9A-Za-z_]|\\(?:C|Control)-(?:M|Meta)-[A-Za-z_]|\\(?:M|Meta)-(?:C|Control)-[A-Za-z_]|\\e|\\[\\\"\'abdfnrtv]|\\\d{1,3}|\\x\h{1,2}|./
+  KEYSEQ_PATTERN = /\\(?:C|Control)-[A-Za-z_]|\\(?:M|Meta)-[0-9A-Za-z_]|\\(?:C|Control)-\\(?:M|Meta)-[A-Za-z_]|\\(?:M|Meta)-\\(?:C|Control)-[A-Za-z_]|\\e|\\[\\\"\'abdfnrtv]|\\\d{1,3}|\\x\h{1,2}|./
 
   class InvalidInputrc < RuntimeError
     attr_accessor :file, :lineno
@@ -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
@@ -188,13 +194,14 @@ class Reline::Config
         # value ignores everything after a space, raw_value does not.
         var, value, raw_value = $1.downcase, $2.partition(' ').first, $2
         bind_variable(var, value, raw_value)
-        next
-      when /\s*("#{KEYSEQ_PATTERN}+")\s*:\s*(.*)\s*$/o
-        key, func_name = $1, $2
-        func_name = func_name.split.first
-        keystroke, func = bind_key(key, func_name)
-        next unless keystroke
-        @additional_key_bindings[@keymap_label].add(@keymap_prefix + keystroke, func)
+      when /^\s*(?:M|Meta)-([a-zA-Z_])\s*:\s*(.*)\s*$/o
+        bind_key("\"\\M-#$1\"", $2)
+      when /^\s*(?:C|Control)-([a-zA-Z_])\s*:\s*(.*)\s*$/o
+        bind_key("\"\\C-#$1\"", $2)
+      when /^\s*(?:(?:C|Control)-(?:M|Meta)|(?:M|Meta)-(?:C|Control))-([a-zA-Z_])\s*:\s*(.*)\s*$/o
+        bind_key("\"\\M-\\C-#$1\"", $2)
+      when /^\s*("#{KEYSEQ_PATTERN}+")\s*:\s*(.*)\s*$/o
+        bind_key($1, $2)
       end
     end
     unless if_stack.empty?
@@ -245,22 +252,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'
@@ -320,7 +311,12 @@ class Reline::Config
     parse_keyseq(str).map { |c| c.chr(Reline.encoding_system_needs) }.join
   end
 
-  def bind_key(key, func_name)
+  def bind_key(key, value)
+    keystroke, func = parse_key_binding(key, value)
+    @additional_key_bindings[@keymap_label].add(@keymap_prefix + keystroke, func) if keystroke
+  end
+
+  def parse_key_binding(key, func_name)
     if key =~ /\A"(.*)"\z/
       keyseq = parse_keyseq($1)
     else
@@ -329,27 +325,19 @@ class Reline::Config
     if func_name =~ /"(.*)"/
       func = parse_keyseq($1)
     else
-      func = func_name.tr(?-, ?_).to_sym # It must be macro.
+      func = func_name.split.first.tr(?-, ?_).to_sym # It must be macro.
     end
     [keyseq, func]
   end
 
   def key_notation_to_code(notation)
     case notation
+    when /(?:\\(?:C|Control)-\\(?:M|Meta)|\\(?:M|Meta)-\\(?:C|Control))-([A-Za-z_])/
+      [?\e.ord, $1.ord % 32]
     when /\\(?:C|Control)-([A-Za-z_])/
-      (1 + $1.downcase.ord - ?a.ord)
+      ($1.upcase.ord % 32)
     when /\\(?:M|Meta)-([0-9A-Za-z_])/
-      modified_key = $1
-      case $1
-      when /[0-9]/
-        ?\M-0.bytes.first + (modified_key.ord - ?0.ord)
-      when /[A-Z]/
-        ?\M-A.bytes.first + (modified_key.ord - ?A.ord)
-      when /[a-z]/
-        ?\M-a.bytes.first + (modified_key.ord - ?a.ord)
-      end
-    when /\\(?:C|Control)-(?:M|Meta)-[A-Za-z_]/, /\\(?:M|Meta)-(?:C|Control)-[A-Za-z_]/
-    # 129 M-^A
+      [?\e.ord, $1.ord]
     when /\\(\d{1,3})/ then $1.to_i(8) # octal
     when /\\x(\h{1,2})/ then $1.to_i(16) # hexadecimal
     when "\\e" then ?\e.ord
@@ -369,11 +357,14 @@ class Reline::Config
   end
 
   def parse_keyseq(str)
-    ret = []
-    str.scan(KEYSEQ_PATTERN) do
-      ret << key_notation_to_code($&)
+    str.scan(KEYSEQ_PATTERN).flat_map do |notation|
+      key_notation_to_code(notation)
     end
-    ret
+  end
+
+  def reload
+    reset_variables
+    read
   end
 
   private def seven_bit_encoding?(encoding)

data/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/lib/reline/history.rb

@@ -19,7 +19,7 @@ class Reline::History < Array
 
   def []=(index, val)
     index = check_index(index)
-    super(index, String.new(val, encoding: Reline.encoding_system_needs))
+    super(index, Reline::Unicode.safe_encode(val, Reline.encoding_system_needs))
   end
 
   def concat(*val)
@@ -45,7 +45,7 @@ class Reline::History < Array
       end
     end
     super(*(val.map{ |v|
-      String.new(v, encoding: Reline.encoding_system_needs)
+      Reline::Unicode.safe_encode(v, Reline.encoding_system_needs)
     }))
   end
 
@@ -56,7 +56,7 @@ class Reline::History < Array
     if @config.history_size.positive?
       shift if size + 1 > @config.history_size
     end
-    super(String.new(val, encoding: Reline.encoding_system_needs))
+    super(Reline::Unicode.safe_encode(val, Reline.encoding_system_needs))
   end
 
   private def check_index(index)

data/lib/reline/io/ansi.rb

@@ -41,7 +41,7 @@ class Reline::ANSI < Reline::IO
   end
 
   def encoding
-    Encoding.default_external
+    @input.external_encoding || Encoding.default_external
   end
 
   def set_default_key_bindings(config, allow_terminfo: true)
@@ -75,7 +75,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]]
@@ -123,27 +126,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)
@@ -245,39 +230,30 @@ class Reline::ANSI < Reline::IO
     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
+      buf.chars.reverse_each do |ch|
+        stdin.ungetc ch
       end
     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?
@@ -347,6 +323,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 +343,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/lib/reline/io/dumb.rb

@@ -21,7 +21,7 @@ class Reline::Dumb < Reline::IO
     elsif RUBY_PLATFORM =~ /mswin|mingw/
       Encoding::UTF_8
     else
-      Encoding::default_external
+      @input.external_encoding || Encoding::default_external
     end
   end
 
@@ -60,7 +60,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/lib/reline/io/windows.rb

@@ -157,16 +157,27 @@ 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.
+  # 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)
+    mode = +"\0\0\0\0"
+    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
@@ -242,7 +253,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
@@ -334,35 +345,38 @@ class Reline::Windows < Reline::IO
     # [18,2] dwMaximumWindowSize.X
     # [20,2] dwMaximumWindowSize.Y
     csbi = 0.chr * 22
-    return if @GetConsoleScreenBufferInfo.call(@hConsoleHandle, 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)
-    @SetConsoleCursorPosition.call(@hConsoleHandle, 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
-      @SetConsoleCursorPosition.call(@hConsoleHandle, y * 65536 + cursor_pos.x)
+      call_with_console_handle(@SetConsoleCursorPosition, (y + top) * 65536 + x)
     elsif val < 0
       move_cursor_down(-val)
     end
@@ -370,62 +384,43 @@ 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)
-      @SetConsoleCursorPosition.call(@hConsoleHandle, (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
-    @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)
-  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')
-      @ScrollConsoleScreenBuffer.call(@hConsoleHandle, 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
-      @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 +434,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)
@@ -462,6 +457,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
@@ -491,7 +508,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) &&