reline 0.6.2 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ec7aa526103ceb5eff3fa7dbbfff8c33f296f9cfb28ec4cc925b28e649dc18c8
-  data.tar.gz: 5c86a58b7769f390a81e9f6ca19a1e64eefad4ad05091544e5a01ef752b21983
+  metadata.gz: 1a8724bc788e9aab24b52fd980230e32b799b9ce5d95d8dcb41e56a2eb953ac4
+  data.tar.gz: f5a979522d2f280c9b45b78782329254b8ab40ad95587afb011748f57b93b35f
 SHA512:
-  metadata.gz: f4e586ed0f631e402d0b4b58fb05f0eec016f1290624021e957de1ced06c15e8638dac34e91c72d4b53a83e2c6b5eb5aadec2b749271d47201773dd220c63827
-  data.tar.gz: 6dcd53d5a30722bb4884f79eb9c70f49ab267b5e285b231237d339a52efdaa597377d308a264ed2cef23802b27aabb38d5ccbfd0c2dce40d631e15a6da5ede68
+  metadata.gz: b89c6c314821ff7e4a5bbb724197a6930c61b0cfc2f9b01eba6e0cf356d3d66425f8121527dd68f3ee639f0a11bd062ff6ddc253c27c5e9ad6d1fae333d4f840
+  data.tar.gz: ae7d3567919f3272bea1cce00435d9d9bd917288f203b6ae816d3856070115b63d40f691596bfefa37aa0beb9bcd8e71db7b82b73692b7c51c24b9f7f1ec9af0

data/lib/reline/io/ansi.rb

@@ -114,13 +114,15 @@ class Reline::ANSI < Reline::IO
   end
 
   def inner_getc(timeout_second)
-    unless @buf.empty?
-      return @buf.shift
-    end
-    until @input.wait_readable(0.01)
+    while true
+      # @buf may change while handling signal, so we need to check it in each loop iteration.
+      return @buf.shift unless @buf.empty?
+      break if @input.wait_readable(0.01)
+
       timeout_second -= 0.01
       return nil if timeout_second <= 0
 
+      # handle_signal may call cursor_pos which modifies @buf
       Reline.core.line_editor.handle_signal
     end
     c = @input.getbyte
@@ -167,17 +169,6 @@ 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
@@ -309,7 +300,6 @@ class Reline::ANSI < Reline::IO
   def prep
     # Enable bracketed paste
     write "\e[?2004h" if Reline.core.config.enable_bracketed_paste && both_tty?
-    retrieve_keybuffer
     nil
   end
 

data/lib/reline/io/windows.rb

@@ -31,6 +31,42 @@ class Reline::Windows < Reline::IO
     @SetConsoleMode = Win32API.new('kernel32', 'SetConsoleMode', ['L', 'L'], 'L')
     @WaitForSingleObject = Win32API.new('kernel32', 'WaitForSingleObject', ['L', 'L'], 'L')
 
+    # Win32API does not have pointer size integer.
+    # Current process pseudo handle (-1)LL seems to fail to be passed to DuplicateHandle.
+    # @GetCurrentProcess = Win32API.new('kernel32', 'GetCurrentProcess', [], 'L')
+    @GetCurrentProcessId = Win32API.new('kernel32', 'GetCurrentProcessId', [], 'L')
+    @OpenProcess = Win32API.new('kernel32', 'OpenProcess', ['L', 'L', 'L'], 'L')
+    @CloseHandle = Win32API.new('kernel32', 'CloseHandle', ['L'], 'L')
+    @DuplicateHandle = Win32API.new('kernel32', 'DuplicateHandle', ['L', 'L', 'L', 'P', 'I', 'I', 'I'], 'L')
+
+    current_process_handle = @OpenProcess.call(
+      0x0040,  # PROCESS_DUP_HANDLE
+      0,       # bInheritHandle
+      @GetCurrentProcessId.call()
+    )
+    duplicate_handle = proc { |handle|
+      dupHandle = "\0" * 8
+      @DuplicateHandle.call(
+        current_process_handle,
+        handle,
+        current_process_handle,
+        dupHandle,
+        0,  # dwDesiredAccess
+        0,  # bInheritHandle
+        2   # dwOptions = DUPLICATE_SAME_ACCESS
+      )
+      dupHandle.unpack1("J")
+    }
+    if (dup = duplicate_handle.call(@hConsoleHandle)) != 0
+      @hConsoleHandle = dup
+      at_exit { @CloseHandle.call(@hConsoleHandle) }
+    end
+    if (dup = duplicate_handle.call(@hConsoleInputHandle)) != 0
+      @hConsoleInputHandle = dup
+      at_exit { @CloseHandle.call(@hConsoleInputHandle) }
+    end
+    @CloseHandle.call(current_process_handle)
+
     @legacy_console = getconsolemode & ENABLE_VIRTUAL_TERMINAL_PROCESSING == 0
   end
 
@@ -162,24 +198,14 @@ class Reline::Windows < Reline::IO
   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 = +"\0\0\0\0"
-    call_with_console_handle(@GetConsoleMode, mode)
+    @GetConsoleMode.call(@hConsoleHandle, mode)
     mode.unpack1('L')
   end
 
   private def setconsolemode(mode)
-    call_with_console_handle(@SetConsoleMode, mode)
+    @SetConsoleMode.call(@hConsoleHandle, mode)
   end
 
   #if @legacy_console
@@ -355,7 +381,7 @@ class Reline::Windows < Reline::IO
     # [18,2] dwMaximumWindowSize.X
     # [20,2] dwMaximumWindowSize.Y
     csbi = 0.chr * 22
-    if call_with_console_handle(@GetConsoleScreenBufferInfo, csbi) != 0
+    if @GetConsoleScreenBufferInfo.call(@hConsoleHandle, csbi) != 0
       # returns [width, height, x, y, attributes, left, top, right, bottom]
       csbi.unpack("s9")
     else
@@ -377,7 +403,7 @@ class Reline::Windows < Reline::IO
 
   def move_cursor_column(val)
     _, _, _, y, = get_console_screen_buffer_info
-    call_with_console_handle(@SetConsoleCursorPosition, y * 65536 + val) if y
+    @SetConsoleCursorPosition.call(@hConsoleHandle, y * 65536 + val) if y
   end
 
   def move_cursor_up(val)
@@ -386,7 +412,7 @@ class Reline::Windows < Reline::IO
       return unless y
       y = (y - top) - val
       y = 0 if y < 0
-      call_with_console_handle(@SetConsoleCursorPosition, (y + top) * 65536 + x)
+      @SetConsoleCursorPosition.call(@hConsoleHandle, (y + top) * 65536 + x)
     elsif val < 0
       move_cursor_down(-val)
     end
@@ -399,7 +425,7 @@ class Reline::Windows < Reline::IO
       screen_height = bottom - top
       y = (y - top) + val
       y = screen_height if y > screen_height
-      call_with_console_handle(@SetConsoleCursorPosition, (y + top) * 65536 + x)
+      @SetConsoleCursorPosition.call(@hConsoleHandle, (y + top) * 65536 + x)
     elsif val < 0
       move_cursor_up(-val)
     end
@@ -409,8 +435,8 @@ class Reline::Windows < Reline::IO
     width, _, x, y, attributes, = get_console_screen_buffer_info
     return unless x
     written = 0.chr * 4
-    call_with_console_handle(@FillConsoleOutputCharacter, 0x20, width - x, y * 65536 + x, written)
-    call_with_console_handle(@FillConsoleOutputAttribute, attributes, width - x, y * 65536 + x, written)
+    @FillConsoleOutputCharacter.call(@hConsoleHandle, 0x20, width - x, y * 65536 + x, written)
+    @FillConsoleOutputAttribute.call(@hConsoleHandle, attributes, width - x, y * 65536 + x, written)
   end
 
   # This only works when the cursor is at the bottom of the scroll range
@@ -428,9 +454,9 @@ class Reline::Windows < Reline::IO
       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)
-      call_with_console_handle(@SetConsoleCursorPosition, screen_topleft)
+      @FillConsoleOutputCharacter.call(@hConsoleHandle, 0x20, fill_length, screen_topleft, written)
+      @FillConsoleOutputAttribute.call(@hConsoleHandle, attributes, fill_length, screen_topleft, written)
+      @SetConsoleCursorPosition.call(@hConsoleHandle, screen_topleft)
     else
       @output.write "\e[2J" "\e[H"
     end
@@ -444,14 +470,14 @@ class Reline::Windows < Reline::IO
     size = 100
     visible = 0 # 0 means false
     cursor_info = [size, visible].pack('Li')
-    call_with_console_handle(@SetConsoleCursorInfo, cursor_info)
+    @SetConsoleCursorInfo.call(@hConsoleHandle, cursor_info)
   end
 
   def show_cursor
     size = 100
     visible = 1 # 1 means true
     cursor_info = [size, visible].pack('Li')
-    call_with_console_handle(@SetConsoleCursorInfo, cursor_info)
+    @SetConsoleCursorInfo.call(@hConsoleHandle, cursor_info)
   end
 
   def set_winch_handler(&handler)

data/lib/reline/io.rb

@@ -10,15 +10,21 @@ module Reline
         require 'reline/io/ansi'
 
         case RbConfig::CONFIG['host_os']
-        when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+        when /mswin|mingw|bccwin|wince|emc/
           require 'reline/io/windows'
           io = Reline::Windows.new
-          if io.msys_tty?
+          if io.msys_tty? || !STDIN.tty?
+            # In either case stdin is not a console (a Cygwin/MSYS pty pipe such
+            # as mintty, or a redirect), so the Win32 console input API cannot
+            # read it.
             Reline::ANSI.new
           else
             io
           end
         else
+          # Ruby built with the msys/cygwin runtime also reaches here. Its tty layer
+          # speaks ANSI in any terminal (mintty pty or Windows console), so the
+          # Win32 console API must not be used. https://github.com/ruby/reline/issues/903
           Reline::ANSI.new
         end
       end

data/lib/reline/key_actor/emacs.rb

@@ -307,7 +307,7 @@ module Reline::KeyActor
     # 152 M-^X
     nil,
     # 153 M-^Y
-    :em_yank_pop,
+    nil,
     # 154 M-^Z
     nil,
     # 155 M-^[
@@ -499,7 +499,7 @@ module Reline::KeyActor
     # 248 M-x
     nil,
     # 249 M-y
-    nil,
+    :em_yank_pop,
     # 250 M-z
     nil,
     # 251 M-{

data/lib/reline/line_editor.rb

@@ -13,6 +13,7 @@ class Reline::LineEditor
   attr_accessor :prompt_proc
   attr_accessor :auto_indent_proc
   attr_accessor :dig_perfect_match_proc
+  attr_accessor :rprompt
 
   VI_MOTIONS = %i{
     ed_prev_char
@@ -43,7 +44,6 @@ class Reline::LineEditor
   RenderedScreen = Struct.new(:base_y, :lines, :cursor_y, keyword_init: true)
 
   CompletionJourneyState = Struct.new(:line_index, :pre, :target, :post, :list, :pointer)
-  NullActionState = [nil, nil].freeze
 
   class MenuInfo
     attr_reader :list
@@ -223,7 +223,7 @@ class Reline::LineEditor
 
   def reset_variables(prompt = '')
     @prompt = prompt.gsub("\n", "\\n")
-    @mark_pointer = nil
+    @mark_position = nil
     @is_multiline = false
     @finished = false
     @history_pointer = nil
@@ -253,8 +253,8 @@ class Reline::LineEditor
     @undo_redo_history = [[[""], 0, 0]]
     @undo_redo_index = 0
     @restoring = false
-    @prev_action_state = NullActionState
-    @next_action_state = NullActionState
+    @prev_action_state = {}
+    @next_action_state = {}
     reset_line
   end
 
@@ -476,6 +476,20 @@ class Reline::LineEditor
       prompt_width = Reline::Unicode.calculate_width(prompt, true)
       [[0, prompt_width, prompt], [prompt_width, Reline::Unicode.calculate_width(line, true), line]]
     end
+
+    # Add rprompt to the first visible line if set and there's room
+    if @rprompt && !@rprompt.empty? && new_lines[0]
+      rprompt_width = Reline::Unicode.calculate_width(@rprompt, true)
+      right_col = screen_width - rprompt_width
+      first_line = new_lines[0]
+      # Calculate the end of the current content (prompt + input)
+      content_end = first_line.sum { |_, width, _| width }
+      # Only show rprompt if there's at least 1 char gap between content and rprompt
+      if right_col > content_end
+        first_line << [right_col, rprompt_width, @rprompt]
+      end
+    end
+
     if @menu_info
       @menu_info.lines(screen_width).each do |item|
         new_lines << [[0, Reline::Unicode.calculate_width(item), item]]
@@ -491,8 +505,8 @@ class Reline::LineEditor
         next if row < 0 || row >= screen_height
 
         dialog_rows = new_lines[row] ||= []
-        # index 0 is for prompt, index 1 is for line, index 2.. is for dialog
-        dialog_rows[index + 2] = [x_range.begin, dialog.width, dialog.contents[row - y_range.begin]]
+        # index 0 is for prompt, index 1 is for line, index 2 is for rprompt, index 3.. is for dialog
+        dialog_rows[index + 3] = [x_range.begin, dialog.width, dialog.contents[row - y_range.begin]]
       end
     end
 
@@ -948,7 +962,7 @@ class Reline::LineEditor
 
   def wrap_method_call(method_symbol, key, with_operator)
     if @waiting_proc
-      @waiting_proc.call(key)
+      @waiting_proc.call(key, method_symbol)
       return
     end
 
@@ -1022,7 +1036,7 @@ class Reline::LineEditor
       @byte_pointer -= byte_size
     end
 
-    @prev_action_state, @next_action_state = @next_action_state, NullActionState
+    @prev_action_state, @next_action_state = @next_action_state, {}
 
     unless @completion_occurs
       @completion_state = CompletionState::NORMAL
@@ -1434,21 +1448,24 @@ class Reline::LineEditor
   end
   alias_method :end_of_line, :ed_move_to_end
 
-  private def generate_searcher(search_key)
+  private def generate_searcher(direction)
     search_word = String.new(encoding: encoding)
     hit_pointer = nil
-    lambda do |key|
+    lambda do |key, key_symbol|
       search_again = false
-      case key
-      when "\C-h", "\C-?"
+      case key_symbol
+      when :em_delete_prev_char, :backward_delete_char
         grapheme_clusters = search_word.grapheme_clusters
         if grapheme_clusters.size > 0
           grapheme_clusters.pop
           search_word = grapheme_clusters.join
         end
-      when "\C-r", "\C-s"
-        search_again = true if search_key == key
-        search_key = key
+      when :reverse_search_history, :vi_search_prev
+        search_again = direction == :reverse
+        direction = :reverse
+      when :forward_search_history, :vi_search_next
+        search_again = direction == :forward
+        direction = :forward
       else
         search_word << key
       end
@@ -1462,11 +1479,11 @@ class Reline::LineEditor
             search_word = Reline.last_incremental_search
           end
           if @history_pointer
-            case search_key
-            when "\C-r"
+            case direction
+            when :reverse
               history_pointer_base = 0
               history = Reline::HISTORY[0..(@history_pointer - 1)]
-            when "\C-s"
+            when :forward
               history_pointer_base = @history_pointer + 1
               history = Reline::HISTORY[(@history_pointer + 1)..-1]
             end
@@ -1475,11 +1492,11 @@ class Reline::LineEditor
             history = Reline::HISTORY
           end
         elsif @history_pointer
-          case search_key
-          when "\C-r"
+          case direction
+          when :reverse
             history_pointer_base = 0
             history = Reline::HISTORY[0..@history_pointer]
-          when "\C-s"
+          when :forward
             history_pointer_base = @history_pointer
             history = Reline::HISTORY[@history_pointer..-1]
           end
@@ -1487,12 +1504,12 @@ class Reline::LineEditor
           history_pointer_base = 0
           history = Reline::HISTORY
         end
-        case search_key
-        when "\C-r"
+        case direction
+        when :reverse
           hit_index = history.rindex { |item|
             item.include?(search_word)
           }
-        when "\C-s"
+        when :forward
           hit_index = history.index { |item|
             item.include?(search_word)
           }
@@ -1502,31 +1519,28 @@ class Reline::LineEditor
           hit = Reline::HISTORY[hit_pointer]
         end
       end
-      case search_key
-      when "\C-r"
-        prompt_name = 'reverse-i-search'
-      when "\C-s"
-        prompt_name = 'i-search'
-      end
+      prompt_name = direction == :forward ? 'i-search' : 'reverse-i-search'
       prompt_name = "failed #{prompt_name}" unless hit
       [search_word, prompt_name, hit_pointer]
     end
   end
 
-  private def incremental_search_history(key)
+  private def incremental_search_history(direction)
     backup = @buffer_of_lines.dup, @line_index, @byte_pointer, @history_pointer, @line_backup_in_history
-    searcher = generate_searcher(key)
-    @searching_prompt = "(reverse-i-search)`': "
+    searcher = generate_searcher(direction)
+    prompt_name = direction == :forward ? 'i-search' : 'reverse-i-search'
+    @searching_prompt = "(#{prompt_name})`': "
     termination_keys = ["\C-j"]
     termination_keys.concat(@config.isearch_terminators.chars) if @config.isearch_terminators
-    @waiting_proc = ->(k) {
+    accept_key_syms = [:em_delete_prev_char, :backward_delete_char, :vi_search_prev, :vi_search_next, :reverse_search_history, :forward_search_history]
+    @waiting_proc = ->(k, key_symbol) {
       if k == "\C-g"
         # cancel search and restore buffer
         @buffer_of_lines, @line_index, @byte_pointer, @history_pointer, @line_backup_in_history = backup
         @searching_prompt = nil
         @waiting_proc = nil
-      elsif !termination_keys.include?(k) && (k.match?(/[[:print:]]/) || k == "\C-h" || k == "\C-?" || k == "\C-r" || k == "\C-s")
-        search_word, prompt_name, hit_pointer = searcher.call(k)
+      elsif !termination_keys.include?(k) && (k.match?(/[[:print:]]/) || accept_key_syms.include?(key_symbol))
+        search_word, prompt_name, hit_pointer = searcher.call(k, key_symbol)
         Reline.last_incremental_search = search_word
         @searching_prompt = "(%s)`%s'" % [prompt_name, search_word]
         @searching_prompt += ': ' unless @is_multiline
@@ -1541,12 +1555,12 @@ class Reline::LineEditor
   end
 
   private def vi_search_prev(key)
-    incremental_search_history(key)
+    incremental_search_history(:reverse)
   end
   alias_method :reverse_search_history, :vi_search_prev
 
   private def vi_search_next(key)
-    incremental_search_history(key)
+    incremental_search_history(:forward)
   end
   alias_method :forward_search_history, :vi_search_next
 
@@ -1779,17 +1793,24 @@ class Reline::LineEditor
 
   private def em_yank(key)
     yanked = @kill_ring.yank
-    insert_text(yanked) if yanked
+    return unless yanked
+
+    before_cursor = current_line.byteslice(0, @byte_pointer)
+    after_cursor = current_line.byteslice(@byte_pointer, current_line.bytesize)
+    set_current_line(before_cursor + yanked + after_cursor, before_cursor.bytesize + yanked.bytesize)
+    set_next_action_state(:em_yank_line, [before_cursor, after_cursor])
   end
   alias_method :yank, :em_yank
 
   private def em_yank_pop(key)
-    yanked, prev_yank = @kill_ring.yank_pop
-    if yanked
-      line, = byteslice!(current_line, @byte_pointer - prev_yank.bytesize, prev_yank.bytesize)
-      set_current_line(line, @byte_pointer - prev_yank.bytesize)
-      insert_text(yanked)
-    end
+    before_cursor, after_cursor = prev_action_state_value(:em_yank_line)
+    return unless before_cursor and after_cursor
+
+    yanked, = @kill_ring.yank_pop
+    return unless yanked
+
+    set_current_line(before_cursor + yanked + after_cursor, before_cursor.bytesize + yanked.bytesize)
+    set_next_action_state(:em_yank_line, [before_cursor, after_cursor])
   end
   alias_method :yank_pop, :em_yank_pop
 
@@ -2182,7 +2203,7 @@ class Reline::LineEditor
   end
 
   private def vi_replace_char(key, arg: 1)
-    @waiting_proc = ->(k) {
+    @waiting_proc = ->(k, _sym) {
       if arg == 1
         byte_size = Reline::Unicode.get_next_mbchar_size(current_line, @byte_pointer)
         before = current_line.byteslice(0, @byte_pointer)
@@ -2206,11 +2227,11 @@ class Reline::LineEditor
   end
 
   private def vi_next_char(key, arg: 1, inclusive: false)
-    @waiting_proc = ->(key_for_proc) { search_next_char(key_for_proc, arg, inclusive: inclusive) }
+    @waiting_proc = ->(key_for_proc, _sym) { search_next_char(key_for_proc, arg, inclusive: inclusive) }
   end
 
   private def vi_to_next_char(key, arg: 1, inclusive: false)
-    @waiting_proc = ->(key_for_proc) { search_next_char(key_for_proc, arg, need_prev_char: true, inclusive: inclusive) }
+    @waiting_proc = ->(key_for_proc, _sym) { search_next_char(key_for_proc, arg, need_prev_char: true, inclusive: inclusive) }
   end
 
   private def search_next_char(key, arg, need_prev_char: false, inclusive: false)
@@ -2253,11 +2274,11 @@ class Reline::LineEditor
   end
 
   private def vi_prev_char(key, arg: 1)
-    @waiting_proc = ->(key_for_proc) { search_prev_char(key_for_proc, arg) }
+    @waiting_proc = ->(key_for_proc, _sym) { search_prev_char(key_for_proc, arg) }
   end
 
   private def vi_to_prev_char(key, arg: 1)
-    @waiting_proc = ->(key_for_proc) { search_prev_char(key_for_proc, arg, true) }
+    @waiting_proc = ->(key_for_proc, _sym) { search_prev_char(key_for_proc, arg, true) }
   end
 
   private def search_prev_char(key, arg, need_next_char = false)
@@ -2303,15 +2324,22 @@ class Reline::LineEditor
   end
 
   private def em_set_mark(key)
-    @mark_pointer = [@byte_pointer, @line_index]
+    cursor_column = Reline::Unicode.calculate_width(current_line.byteslice(0, @byte_pointer))
+    @mark_position = [@line_index, cursor_column]
   end
   alias_method :set_mark, :em_set_mark
 
   private def em_exchange_mark(key)
-    return unless @mark_pointer
-    new_pointer = [@byte_pointer, @line_index]
-    @byte_pointer, @line_index = @mark_pointer
-    @mark_pointer = new_pointer
+    return unless @mark_position
+    line_index, cursor_column = @mark_position
+    em_set_mark(key)
+    if @buffer_of_lines.size <= line_index
+      @line_index = @buffer_of_lines.size - 1
+      @byte_pointer = current_line.bytesize
+    else
+      @line_index = line_index
+      calculate_nearest_cursor(cursor_column)
+    end
   end
   alias_method :exchange_point_and_mark, :em_exchange_mark
 
@@ -2343,11 +2371,11 @@ class Reline::LineEditor
   end
 
   private def prev_action_state_value(type)
-    @prev_action_state[0] == type ? @prev_action_state[1] : nil
+    @prev_action_state[type]
   end
 
   private def set_next_action_state(type, value)
-    @next_action_state = [type, value]
+    @next_action_state[type] = value
   end
 
   private def re_read_init_file(_key)

data/lib/reline/unicode.rb

@@ -37,7 +37,7 @@ class Reline::Unicode
 
   NON_PRINTING_START = "\1"
   NON_PRINTING_END = "\2"
-  CSI_REGEXP = /\e\[[\d;]*[ABCDEFGHJKSTfminsuhl]/
+  CSI_REGEXP = /\e\[[\x30-\x3f]*[\x20-\x2f]*[a-zA-Z]/
   OSC_REGEXP = /\e\]\d+(?:;[^;\a\e]+)*(?:\a|\e\\)/
   WIDTH_SCANNER = /\G(?:(#{NON_PRINTING_START})|(#{NON_PRINTING_END})|(#{CSI_REGEXP})|(#{OSC_REGEXP})|(\X))/o
 

data/lib/reline/version.rb

@@ -1,3 +1,3 @@
 module Reline
-  VERSION = '0.6.2'
+  VERSION = '0.7.0'
 end

data/lib/reline.rb

@@ -247,19 +247,19 @@ module Reline
     } # :nodoc:
     Reline::DEFAULT_DIALOG_CONTEXT = Array.new # :nodoc:
 
-    def readmultiline(prompt = '', add_hist = false, &confirm_multiline_termination)
+    def readmultiline(_prompt = '', _add_history = false, prompt: _prompt, add_history: _add_history, rprompt: nil, &confirm_multiline_termination)
       @mutex.synchronize do
         unless confirm_multiline_termination
           raise ArgumentError.new('#readmultiline needs block to confirm multiline termination')
         end
 
         io_gate.with_raw_input do
-          inner_readline(prompt, add_hist, true, &confirm_multiline_termination)
+          inner_readline(prompt, add_history, true, rprompt: rprompt, &confirm_multiline_termination)
         end
 
         whole_buffer = line_editor.whole_buffer.dup
         whole_buffer.taint if RUBY_VERSION < '2.7'
-        if add_hist and whole_buffer and whole_buffer.chomp("\n").size > 0
+        if add_history and whole_buffer and whole_buffer.chomp("\n").size > 0
           Reline::HISTORY << whole_buffer
         end
 
@@ -273,15 +273,15 @@ module Reline
       end
     end
 
-    def readline(prompt = '', add_hist = false)
+    def readline(_prompt = '', _add_history = false, prompt: _prompt, add_history: _add_history, rprompt: nil)
       @mutex.synchronize do
         io_gate.with_raw_input do
-          inner_readline(prompt, add_hist, false)
+          inner_readline(prompt, add_history, false, rprompt: rprompt)
         end
 
         line = line_editor.line.dup
         line.taint if RUBY_VERSION < '2.7'
-        if add_hist and line and line.chomp("\n").size > 0
+        if add_history and line and line.chomp("\n").size > 0
           Reline::HISTORY << line.chomp("\n")
         end
 
@@ -290,7 +290,7 @@ module Reline
       end
     end
 
-    private def inner_readline(prompt, add_hist, multiline, &confirm_multiline_termination)
+    private def inner_readline(prompt, add_history, multiline, rprompt: nil, &confirm_multiline_termination)
       if ENV['RELINE_STDERR_TTY']
         if io_gate.win?
           $stderr = File.open(ENV['RELINE_STDERR_TTY'], 'a')
@@ -323,6 +323,7 @@ module Reline
       line_editor.prompt_proc = prompt_proc
       line_editor.auto_indent_proc = auto_indent_proc
       line_editor.dig_perfect_match_proc = dig_perfect_match_proc
+      line_editor.rprompt = rprompt&.encode(encoding)
 
       pre_input_hook&.call
 
@@ -442,13 +443,13 @@ module Reline
   ##
   # :singleton-method: readmultiline
   # :call-seq:
-  #   readmultiline(prompt = '', add_hist = false, &confirm_multiline_termination) -> string or nil
+  #   readmultiline(prompt = '', add_history = false, &confirm_multiline_termination) -> string or nil
   def_single_delegators :core, :readmultiline
 
   ##
   # :singleton-method: readline
   # :call-seq:
-  #   readline(prompt = '', add_hist = false) -> string or nil
+  #   readline(prompt = '', add_history = false) -> string or nil
   def_single_delegators :core, :readline
   def_single_delegators :core, :completion_case_fold, :completion_case_fold=
   def_single_delegators :core, :completion_quote_character

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: reline
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.7.0
 platform: ruby
 authors:
 - aycabta