reline 0.5.0.pre.1 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a6fdc2426aceadd0680462674da1132c7042924e9fda18daecd68b82e459a867
-  data.tar.gz: 5fc586dfacfd1cc5524320b0e3190982098fbdaf541a6ff56f9c153aa828560c
+  metadata.gz: 47d262bd9b8ab9b3fb314863af068783c217d53177f947372eb979df2ceaf3cf
+  data.tar.gz: 8112b4441c7946a697adf3d16ec79531fc744fac132ea3cca89ef16b9b6518d3
 SHA512:
-  metadata.gz: 052abb950ef133821f1c3bf43f4727e8ef6afe7210fb9a9f56df65ad1a16a96d54cfc519ecbab94c8b5502d8c6976fdfc7b5e87effb4f7b9e15a800ffaefa92f
-  data.tar.gz: 617b9876da860ac3b08fd659e9ef8e7cda3afc189e496b34cd116d9850bee9ed176e68f129b4ceff6443f3f3992460ef22ddad9d16c2a6dbdf07a3ee020a25e0
+  metadata.gz: 22570f23bfa74602ef627bf977982304b0e5849cbc52abb33f321a32b3860348eabb3efd88bfcfa6b46032433a012813a0fa9aa70422438d0f0694a724ca3055
+  data.tar.gz: 6a30e3c69c1a64149a5cd0517e3c46c6dfb9d724532ded4ab4475c6b595bcf5cdf6b6ffd1b9d32156b8a8a447885bb918d35f78be90934a2e2513f87fdf40bb0

data/lib/reline/ansi.rb

@@ -3,6 +3,8 @@ require 'io/wait'
 require_relative 'terminfo'
 
 class Reline::ANSI
+  RESET_COLOR = "\e[0m"
+
   CAPNAME_KEY_BINDINGS = {
     'khome' => :ed_move_to_beg,
     'kend'  => :ed_move_to_end,
@@ -149,7 +151,11 @@ class Reline::ANSI
   end
 
   def self.with_raw_input
-    @@input.raw { yield }
+    if @@input.tty?
+      @@input.raw(intr: true) { yield }
+    else
+      yield
+    end
   end
 
   @@buf = []
@@ -157,11 +163,13 @@ class Reline::ANSI
     unless @@buf.empty?
       return @@buf.shift
     end
-    until c = @@input.raw(intr: true) { @@input.wait_readable(0.1) && @@input.getbyte }
-      timeout_second -= 0.1
+    until @@input.wait_readable(0.01)
+      timeout_second -= 0.01
       return nil if timeout_second <= 0
-      Reline.core.line_editor.resize
+
+      Reline.core.line_editor.handle_signal
     end
+    c = @@input.getbyte
     (c == 0x16 && @@input.raw(min: 0, time: 0, &:getbyte)) || c
   rescue Errno::EIO
     # Maybe the I/O has been closed.
@@ -307,7 +315,7 @@ class Reline::ANSI
   end
 
   def self.hide_cursor
-    if Reline::Terminfo.enabled?
+    if Reline::Terminfo.enabled? && Reline::Terminfo.term_supported?
       begin
         @@output.write Reline::Terminfo.tigetstr('civis')
       rescue Reline::Terminfo::TerminfoError
@@ -319,7 +327,7 @@ class Reline::ANSI
   end
 
   def self.show_cursor
-    if Reline::Terminfo.enabled?
+    if Reline::Terminfo.enabled? && Reline::Terminfo.term_supported?
       begin
         @@output.write Reline::Terminfo.tigetstr('cnorm')
       rescue Reline::Terminfo::TerminfoError

data/lib/reline/face.rb

@@ -186,9 +186,9 @@ class Reline::Face
       conf.define :scrollbar, style: :reset
     end
     config(:completion_dialog) do |conf|
-      conf.define :default, foreground: :white, background: :cyan
-      conf.define :enhanced, foreground: :white, background: :magenta
-      conf.define :scrollbar, foreground: :white, background: :cyan
+      conf.define :default, foreground: :bright_white, background: :gray
+      conf.define :enhanced, foreground: :black, background: :white
+      conf.define :scrollbar, foreground: :white, background: :gray
     end
   end
 

data/lib/reline/general_io.rb

@@ -1,6 +1,8 @@
 require 'io/wait'
 
 class Reline::GeneralIO
+  RESET_COLOR = '' # Do not send color reset sequence
+
   def self.reset(encoding: nil)
     @@pasting = false
     if encoding
@@ -44,6 +46,7 @@ class Reline::GeneralIO
     end
     c = nil
     loop do
+      Reline.core.line_editor.handle_signal
       result = @@input.wait_readable(0.1)
       next if result.nil?
       c = @@input.read(1)
@@ -100,14 +103,6 @@ class Reline::GeneralIO
     @@pasting
   end
 
-  def self.start_pasting
-    @@pasting = true
-  end
-
-  def self.finish_pasting
-    @@pasting = false
-  end
-
   def self.prep
   end
 

data/lib/reline/history.rb

@@ -62,7 +62,7 @@ class Reline::History < Array
   private def check_index(index)
     index += size if index < 0
     if index < -2147483648 or 2147483647 < index
-      raise RangeError.new("integer #{index} too big to convert to `int'")
+      raise RangeError.new("integer #{index} too big to convert to 'int'")
     end
     # If history_size is negative, history size is unlimited.
     if @config.history_size.positive?

data/lib/reline/kill_ring.rb

@@ -14,7 +14,7 @@ class Reline::KillRing
     end
 
     def ==(other)
-      object_id == other.object_id
+      equal?(other)
     end
   end
 
@@ -68,7 +68,7 @@ class Reline::KillRing
   def append(string, before_p = false)
     case @state
     when State::FRESH, State::YANK
-      @ring << RingPoint.new(string)
+      @ring << RingPoint.new(+string)
       @state = State::CONTINUED
     when State::CONTINUED, State::PROCESSED
       if before_p

data/lib/reline/line_editor.rb

@@ -41,21 +41,42 @@ class Reline::LineEditor
     NORMAL = :normal
     COMPLETION = :completion
     MENU = :menu
-    JOURNEY = :journey
     MENU_WITH_PERFECT_MATCH = :menu_with_perfect_match
     PERFECT_MATCH = :perfect_match
   end
 
-  CompletionJourneyData = Struct.new(:preposing, :postposing, :list, :pointer)
-  MenuInfo = Struct.new(:target, :list)
+  RenderedScreen = Struct.new(:base_y, :lines, :cursor_y, keyword_init: true)
+
+  CompletionJourneyState = Struct.new(:line_index, :pre, :target, :post, :list, :pointer)
+
+  class MenuInfo
+    attr_reader :list
+
+    def initialize(list)
+      @list = list
+    end
+
+    def lines(screen_width)
+      return [] if @list.empty?
+
+      list = @list.sort
+      sizes = list.map { |item| Reline::Unicode.calculate_width(item) }
+      item_width = sizes.max + 2
+      num_cols = [screen_width / item_width, 1].max
+      num_rows = list.size.fdiv(num_cols).ceil
+      list_with_padding = list.zip(sizes).map { |item, size| item + ' ' * (item_width - size) }
+      aligned = (list_with_padding + [nil] * (num_rows * num_cols - list_with_padding.size)).each_slice(num_rows).to_a.transpose
+      aligned.map do |row|
+        row.join.rstrip
+      end
+    end
+  end
 
-  PROMPT_LIST_CACHE_TIMEOUT = 0.5
   MINIMUM_SCROLLBAR_HEIGHT = 1
 
   def initialize(config, encoding)
     @config = config
     @completion_append_character = ''
-    @cursor_base_y = 0
     @screen_size = Reline::IOGate.get_screen_size
     reset_variables(encoding: encoding)
   end
@@ -65,6 +86,9 @@ class Reline::LineEditor
   end
 
   def set_pasting_state(in_pasting)
+    # While pasting, text to be inserted is stored to @continuous_insertion_buffer.
+    # After pasting, this buffer should be force inserted.
+    process_insert(force: true) if @in_pasting && !in_pasting
     @in_pasting = in_pasting
   end
 
@@ -82,7 +106,7 @@ class Reline::LineEditor
     end
   end
 
-  private def check_multiline_prompt(buffer)
+  private def check_multiline_prompt(buffer, mode_string)
     if @vi_arg
       prompt = "(arg: #{@vi_arg}) "
     elsif @searching_prompt
@@ -94,7 +118,6 @@ class Reline::LineEditor
       prompt_list = @prompt_proc.(buffer).map { |pr| pr.gsub("\n", "\\n") }
       prompt_list.map!{ prompt } if @vi_arg or @searching_prompt
       prompt_list = [prompt] if prompt_list.empty?
-      mode_string = check_mode_string
       prompt_list = prompt_list.map{ |pr| mode_string + pr } if mode_string
       prompt = prompt_list[@line_index]
       prompt = prompt_list[0] if prompt.nil?
@@ -106,19 +129,15 @@ class Reline::LineEditor
       end
       prompt_list
     else
-      mode_string = check_mode_string
       prompt = mode_string + prompt if mode_string
       [prompt] * buffer.size
     end
   end
 
   def reset(prompt = '', encoding:)
-    @cursor_base_y = Reline::IOGate.cursor_pos.y
     @screen_size = Reline::IOGate.get_screen_size
     reset_variables(prompt, encoding: encoding)
-    Reline::IOGate.set_winch_handler do
-      @resized = true
-    end
+    @rendered_screen.base_y = Reline::IOGate.cursor_pos.y
     if ENV.key?('RELINE_ALT_SCROLLBAR')
       @full_block = '::'
       @upper_half_block = "''"
@@ -142,41 +161,53 @@ class Reline::LineEditor
     end
   end
 
-  def resize
+  def handle_signal
+    handle_interrupted
+    handle_resized
+  end
+
+  private def handle_resized
     return unless @resized
 
-    Reline::IOGate.hide_cursor
     @screen_size = Reline::IOGate.get_screen_size
     @resized = false
     scroll_into_view
-    Reline::IOGate.move_cursor_up @cursor_y
-    @cursor_base_y = Reline::IOGate.cursor_pos.y
-    @cursor_y = 0
-    @rendered_screen_cache = nil
+    Reline::IOGate.move_cursor_up @rendered_screen.cursor_y
+    @rendered_screen.base_y = Reline::IOGate.cursor_pos.y
+    @rendered_screen.lines = []
+    @rendered_screen.cursor_y = 0
     render_differential
-    Reline::IOGate.show_cursor
+  end
+
+  private def handle_interrupted
+    return unless @interrupted
+
+    @interrupted = false
+    clear_dialogs
+    scrolldown = render_differential
+    Reline::IOGate.scroll_down scrolldown
+    Reline::IOGate.move_cursor_column 0
+    @rendered_screen.lines = []
+    @rendered_screen.cursor_y = 0
+    case @old_trap
+    when 'DEFAULT', 'SYSTEM_DEFAULT'
+      raise Interrupt
+    when 'IGNORE'
+      # Do nothing
+    when 'EXIT'
+      exit
+    else
+      @old_trap.call if @old_trap.respond_to?(:call)
+    end
   end
 
   def set_signal_handlers
-    @old_trap = Signal.trap('INT') {
-      Reline::IOGate.hide_cursor
-      clear_dialogs
-      scrolldown = render_differential
-      Reline::IOGate.scroll_down scrolldown
-      Reline::IOGate.move_cursor_column 0
-      @rendered_screen_cache = nil
-      Reline::IOGate.show_cursor
-      case @old_trap
-      when 'DEFAULT', 'SYSTEM_DEFAULT'
-        raise Interrupt
-      when 'IGNORE'
-        # Do nothing
-      when 'EXIT'
-        exit
-      else
-        @old_trap.call if @old_trap.respond_to?(:call)
-      end
-    }
+    Reline::IOGate.set_winch_handler do
+      @resized = true
+    end
+    @old_trap = Signal.trap('INT') do
+      @interrupted = true
+    end
   end
 
   def finalize
@@ -193,7 +224,6 @@ class Reline::LineEditor
     @encoding = encoding
     @is_multiline = false
     @finished = false
-    @cleared = false
     @history_pointer = nil
     @kill_ring ||= Reline::KillRing.new
     @vi_clipboard = ''
@@ -201,13 +231,13 @@ class Reline::LineEditor
     @waiting_proc = nil
     @waiting_operator_proc = nil
     @waiting_operator_vi_arg = nil
-    @completion_journey_data = nil
+    @completion_journey_state = nil
     @completion_state = CompletionState::NORMAL
     @perfect_matched = nil
     @menu_info = nil
-    @first_prompt = true
     @searching_prompt = nil
     @first_char = true
+    @just_cursor_moving = false
     @eof = false
     @continuous_insertion_buffer = String.new(encoding: @encoding)
     @scroll_partial_screen = 0
@@ -215,10 +245,10 @@ class Reline::LineEditor
     @in_pasting = false
     @auto_indent_proc = nil
     @dialogs = []
+    @interrupted = false
     @resized = false
-    @cursor_y = 0
     @cache = {}
-    @rendered_screen_cache = nil
+    @rendered_screen = RenderedScreen.new(base_y: 0, lines: [], cursor_y: 0)
     reset_line
   end
 
@@ -266,20 +296,6 @@ class Reline::LineEditor
     Reline::Unicode.split_by_width(str, max_width, @encoding)
   end
 
-  private def scroll_down(val)
-    if @cursor_base_y + @cursor_y + val < screen_height
-      Reline::IOGate.move_cursor_down(val)
-      @cursor_y += val
-    else
-      move = screen_height - @cursor_base_y - @cursor_y - 1
-      scroll = val - move
-      Reline::IOGate.scroll_down(move)
-      Reline::IOGate.scroll_down(scroll)
-      @cursor_y += move
-      @cursor_base_y = [@cursor_base_y - scroll, 0].max
-    end
-  end
-
   def current_byte_pointer_cursor
     calculate_width(current_line.byteslice(0, @byte_pointer))
   end
@@ -334,8 +350,8 @@ class Reline::LineEditor
   end
 
   def prompt_list
-    with_cache(__method__, whole_lines, @vi_arg, @searching_prompt) do |lines|
-      check_multiline_prompt(lines)
+    with_cache(__method__, whole_lines, check_mode_string, @vi_arg, @searching_prompt) do |lines, mode_string|
+      check_multiline_prompt(lines, mode_string)
     end
   end
 
@@ -387,12 +403,12 @@ class Reline::LineEditor
         # do nothing
       elsif level == :blank
         Reline::IOGate.move_cursor_column base_x
-        @output.write "\e[0m#{' ' * width}"
+        @output.write "#{Reline::IOGate::RESET_COLOR}#{' ' * width}"
       else
         x, w, content = new_items[level]
         content = Reline::Unicode.take_range(content, base_x - x, width) unless x == base_x && w == width
         Reline::IOGate.move_cursor_column base_x
-        @output.write "\e[0m#{content}\e[0m"
+        @output.write "#{Reline::IOGate::RESET_COLOR}#{content}#{Reline::IOGate::RESET_COLOR}"
       end
       base_x += width
     end
@@ -402,12 +418,14 @@ class Reline::LineEditor
     end
   end
 
-  def editor_cursor_position
-    line = ' ' * calculate_width(prompt_list[@line_index], true) + whole_lines[@line_index].byteslice(0, @byte_pointer)
-    wrapped_line_before_cursor = split_by_width(line, screen_width).first.compact
-    editor_cursor_y = wrapped_lines[0...@line_index].sum(&:size) + wrapped_line_before_cursor.size - 1
-    editor_cursor_x = calculate_width(wrapped_line_before_cursor.last)
-    [editor_cursor_x, editor_cursor_y]
+  # Calculate cursor position in word wrapped content.
+  def wrapped_cursor_position
+    prompt_width = calculate_width(prompt_list[@line_index], true)
+    line_before_cursor = whole_lines[@line_index].byteslice(0, @byte_pointer)
+    wrapped_line_before_cursor = split_by_width(' ' * prompt_width + line_before_cursor, screen_width).first.compact
+    wrapped_cursor_y = wrapped_lines[0...@line_index].sum(&:size) + wrapped_line_before_cursor.size - 1
+    wrapped_cursor_x = calculate_width(wrapped_line_before_cursor.last)
+    [wrapped_cursor_x, wrapped_cursor_y]
   end
 
   def clear_dialogs
@@ -418,19 +436,23 @@ class Reline::LineEditor
   end
 
   def update_dialogs(key = nil)
-    @dialog_initialzed = true
-    editor_cursor_x, editor_cursor_y = editor_cursor_position
+    wrapped_cursor_x, wrapped_cursor_y = wrapped_cursor_position
     @dialogs.each do |dialog|
       dialog.trap_key = nil
-      update_each_dialog(dialog, editor_cursor_x, editor_cursor_y - screen_scroll_top, key)
+      update_each_dialog(dialog, wrapped_cursor_x, wrapped_cursor_y - screen_scroll_top, key)
     end
   end
 
+  def render_finished
+    clear_rendered_lines
+    render_full_content
+  end
+
   def clear_rendered_lines
-    Reline::IOGate.move_cursor_up @cursor_y
+    Reline::IOGate.move_cursor_up @rendered_screen.cursor_y
     Reline::IOGate.move_cursor_column 0
 
-    num_lines = @rendered_screen_cache&.size
+    num_lines = @rendered_screen.lines.size
     return unless num_lines && num_lines >= 1
 
     Reline::IOGate.move_cursor_down num_lines - 1
@@ -439,7 +461,8 @@ class Reline::LineEditor
       Reline::IOGate.move_cursor_up 1
     end
     Reline::IOGate.erase_after_cursor
-    @rendered_screen_cache = nil
+    @rendered_screen.lines = []
+    @rendered_screen.cursor_y = 0
   end
 
   def render_full_content
@@ -455,23 +478,20 @@ class Reline::LineEditor
     return unless prompt && !@is_multiline
 
     # Readline's test `TestRelineAsReadline#test_readline` requires first output to be prompt, not cursor reset escape sequence.
-    @rendered_screen_cache = [[[0, Reline::Unicode.calculate_width(prompt, true), prompt]]]
+    @rendered_screen.lines = [[[0, Reline::Unicode.calculate_width(prompt, true), prompt]]]
+    @rendered_screen.cursor_y = 0
     @output.write prompt
   end
 
   def render_differential
-    unless @dialog_initialzed
-      update_dialogs
-    end
-
-    editor_cursor_x, editor_cursor_y = editor_cursor_position
+    wrapped_cursor_x, wrapped_cursor_y = wrapped_cursor_position
 
-    rendered_lines = @rendered_screen_cache || []
+    rendered_lines = @rendered_screen.lines
     new_lines = wrapped_lines.flatten[screen_scroll_top, screen_height].map do |l|
       [[0, Reline::Unicode.calculate_width(l, true), l]]
     end
     if @menu_info
-      @menu_info.list.sort!.each do |item|
+      @menu_info.lines(screen_width).each do |item|
         new_lines << [[0, Reline::Unicode.calculate_width(item), item]]
       end
       @menu_info = nil # TODO: do not change state here
@@ -480,7 +500,7 @@ class Reline::LineEditor
     @dialogs.each_with_index do |dialog, index|
       next unless dialog.contents
 
-      x_range, y_range = dialog_range dialog, editor_cursor_y - screen_scroll_top
+      x_range, y_range = dialog_range dialog, wrapped_cursor_y - screen_scroll_top
       y_range.each do |row|
         next if row < 0 || row >= screen_height
         dialog_rows = new_lines[row] ||= []
@@ -488,77 +508,58 @@ class Reline::LineEditor
       end
     end
 
-    num_lines = [[new_lines.size, rendered_lines.size].max, screen_height].min
-    scroll_down(num_lines - 1 - @cursor_y) if (num_lines - 1 - @cursor_y) > 0
-    @cursor_y = num_lines - 1
-    num_lines.times do |i|
-      rendered_line = rendered_lines[i] || []
-      line_to_render = new_lines[i] || []
-      next if rendered_line == line_to_render
-
-      Reline::IOGate.move_cursor_down i - @cursor_y
-      @cursor_y = i
-      unless rendered_lines[i]
-        Reline::IOGate.move_cursor_column 0
-        Reline::IOGate.erase_after_cursor
+    cursor_y = @rendered_screen.cursor_y
+    if new_lines != rendered_lines
+      # Hide cursor while rendering to avoid cursor flickering.
+      Reline::IOGate.hide_cursor
+      num_lines = [[new_lines.size, rendered_lines.size].max, screen_height].min
+      if @rendered_screen.base_y + num_lines > screen_height
+        Reline::IOGate.scroll_down(num_lines - cursor_y - 1)
+        @rendered_screen.base_y = screen_height - num_lines
+        cursor_y = num_lines - 1
+      end
+      num_lines.times do |i|
+        rendered_line = rendered_lines[i] || []
+        line_to_render = new_lines[i] || []
+        next if rendered_line == line_to_render
+
+        Reline::IOGate.move_cursor_down i - cursor_y
+        cursor_y = i
+        unless rendered_lines[i]
+          Reline::IOGate.move_cursor_column 0
+          Reline::IOGate.erase_after_cursor
+        end
+        render_line_differential(rendered_line, line_to_render)
       end
-      render_line_differential(rendered_line, line_to_render)
+      @rendered_screen.lines = new_lines
+      Reline::IOGate.show_cursor
     end
-    @rendered_screen_cache = new_lines
-    y = editor_cursor_y - screen_scroll_top
-    Reline::IOGate.move_cursor_column editor_cursor_x
-    Reline::IOGate.move_cursor_down y - @cursor_y
-    @cursor_y = y
-    new_lines.size - @cursor_y
+    y = wrapped_cursor_y - screen_scroll_top
+    Reline::IOGate.move_cursor_column wrapped_cursor_x
+    Reline::IOGate.move_cursor_down y - cursor_y
+    @rendered_screen.cursor_y = y
+    new_lines.size - y
   end
 
   def current_row
-    wrapped_lines.flatten[editor_cursor_y]
-  end
-
-  def upper_space_height
-    @cursor_y - 1
+    wrapped_lines.flatten[wrapped_cursor_y]
   end
 
-  def rest_height
-    screen_height - @cursor_y - @cursor_base_y - 1
+  def upper_space_height(wrapped_cursor_y)
+    wrapped_cursor_y - screen_scroll_top
   end
 
-  def rerender_all
-    Reline::IOGate.hide_cursor
-    process_insert(force: true)
-    handle_cleared
-    render_differential unless @in_pasting
-    Reline::IOGate.show_cursor
-  end
-
-  def handle_cleared
-    return unless @cleared
-
-    @cleared = false
-    @rendered_screen_cache = nil
-    Reline::IOGate.clear_screen
-    @screen_size = Reline::IOGate.get_screen_size
-    @cursor_base_y = 0
-    @cursor_y = 0
-    scroll_into_view
-    render_differential
+  def rest_height(wrapped_cursor_y)
+    screen_height - wrapped_cursor_y + screen_scroll_top - @rendered_screen.base_y - 1
   end
 
   def rerender
-    Reline::IOGate.hide_cursor
-    finished = finished?
-    handle_cleared
-    if finished
-      clear_rendered_lines
-      render_full_content
-    elsif !@in_pasting
-      render_differential
-    end
-    Reline::IOGate.show_cursor
+    render_differential unless @in_pasting
   end
 
   class DialogProcScope
+    CompletionJourneyData = Struct.new(:preposing, :postposing, :list, :pointer)
+
     def initialize(line_editor, config, proc_to_exec, context)
       @line_editor = line_editor
       @config = config
@@ -617,12 +618,12 @@ class Reline::LineEditor
     end
 
     def preferred_dialog_height
-      _editor_cursor_x, editor_cursor_y = @line_editor.editor_cursor_position
-      [editor_cursor_y - @line_editor.screen_scroll_top, @line_editor.rest_height, (screen_height + 6) / 5].max
+      _wrapped_cursor_x, wrapped_cursor_y = @line_editor.wrapped_cursor_position
+      [@line_editor.upper_space_height(wrapped_cursor_y), @line_editor.rest_height(wrapped_cursor_y), (screen_height + 6) / 5].max
     end
 
     def completion_journey_data
-      @line_editor.instance_variable_get(:@completion_journey_data)
+      @line_editor.dialog_proc_scope_completion_journey_data
     end
 
     def config
@@ -747,16 +748,15 @@ class Reline::LineEditor
     else
       scrollbar_pos = nil
     end
-    upper_space = upper_space_height
     dialog.column = dialog_render_info.pos.x
     dialog.width += @block_elem_width if scrollbar_pos
     diff = (dialog.column + dialog.width) - screen_width
     if diff > 0
       dialog.column -= diff
     end
-    if (rest_height - dialog_render_info.pos.y) >= height
+    if rest_height(screen_scroll_top + cursor_row) - dialog_render_info.pos.y >= height
       dialog.vertical_offset = dialog_render_info.pos.y + 1
-    elsif upper_space >= height
+    elsif cursor_row >= height
       dialog.vertical_offset = dialog_render_info.pos.y - height
     else
       dialog.vertical_offset = dialog_render_info.pos.y + 1
@@ -794,7 +794,7 @@ class Reline::LineEditor
     if after = @output_modifier_proc&.call("#{before.join("\n")}\n", complete: complete)
       after.lines("\n").map { |l| l.chomp('') }
     else
-      before
+      before.map { |l| Reline::Unicode.escape_for_print(l) }
     end
   end
 
@@ -802,8 +802,8 @@ class Reline::LineEditor
     @config.editing_mode
   end
 
-  private def menu(target, list)
-    @menu_info = MenuInfo.new(target, list)
+  private def menu(_target, list)
+    @menu_info = MenuInfo.new(list)
   end
 
   private def complete_internal_proc(list, is_menu)
@@ -831,7 +831,7 @@ class Reline::LineEditor
         item_mbchars = item.grapheme_clusters
       end
       size = [memo_mbchars.size, item_mbchars.size].min
-      result = ''
+      result = +''
       size.times do |i|
         if @config.completion_ignore_case
           if memo_mbchars[i].casecmp?(item_mbchars[i])
@@ -852,9 +852,9 @@ class Reline::LineEditor
     [target, preposing, completed, postposing]
   end
 
-  private def complete(list, just_show_list = false)
+  private def complete(list, just_show_list)
     case @completion_state
-    when CompletionState::NORMAL, CompletionState::JOURNEY
+    when CompletionState::NORMAL
       @completion_state = CompletionState::COMPLETION
     when CompletionState::PERFECT_MATCH
       @dig_perfect_match_proc&.(@perfect_matched)
@@ -888,52 +888,50 @@ class Reline::LineEditor
       end
       if not just_show_list and target < completed
         @buffer_of_lines[@line_index] = (preposing + completed + completion_append_character.to_s + postposing).split("\n")[@line_index] || String.new(encoding: @encoding)
-        line_to_pointer = (preposing + completed + completion_append_character.to_s).split("\n").last || String.new(encoding: @encoding)
+        line_to_pointer = (preposing + completed + completion_append_character.to_s).split("\n")[@line_index] || String.new(encoding: @encoding)
         @byte_pointer = line_to_pointer.bytesize
       end
     end
   end
 
-  private def move_completed_list(list, direction)
-    case @completion_state
-    when CompletionState::NORMAL, CompletionState::COMPLETION,
-         CompletionState::MENU, CompletionState::MENU_WITH_PERFECT_MATCH
-      @completion_state = CompletionState::JOURNEY
-      result = retrieve_completion_block
-      return if result.nil?
-      preposing, target, postposing = result
-      @completion_journey_data = CompletionJourneyData.new(
-        preposing, postposing,
-        [target] + list.select{ |item| item.start_with?(target) }, 0)
-      if @completion_journey_data.list.size == 1
-        @completion_journey_data.pointer = 0
-      else
-        case direction
-        when :up
-          @completion_journey_data.pointer = @completion_journey_data.list.size - 1
-        when :down
-          @completion_journey_data.pointer = 1
-        end
-      end
-      @completion_state = CompletionState::JOURNEY
-    else
-      case direction
-      when :up
-        @completion_journey_data.pointer -= 1
-        if @completion_journey_data.pointer < 0
-          @completion_journey_data.pointer = @completion_journey_data.list.size - 1
-        end
-      when :down
-        @completion_journey_data.pointer += 1
-        if @completion_journey_data.pointer >= @completion_journey_data.list.size
-          @completion_journey_data.pointer = 0
-        end
-      end
+  def dialog_proc_scope_completion_journey_data
+    return nil unless @completion_journey_state
+    line_index = @completion_journey_state.line_index
+    pre_lines = @buffer_of_lines[0...line_index].map { |line| line + "\n" }
+    post_lines = @buffer_of_lines[(line_index + 1)..-1].map { |line| line + "\n" }
+    DialogProcScope::CompletionJourneyData.new(
+      pre_lines.join + @completion_journey_state.pre,
+      @completion_journey_state.post + post_lines.join,
+      @completion_journey_state.list,
+      @completion_journey_state.pointer
+    )
+  end
+
+  private def move_completed_list(direction)
+    @completion_journey_state ||= retrieve_completion_journey_state
+    return false unless @completion_journey_state
+
+    if (delta = { up: -1, down: +1 }[direction])
+      @completion_journey_state.pointer = (@completion_journey_state.pointer + delta) % @completion_journey_state.list.size
     end
-    completed = @completion_journey_data.list[@completion_journey_data.pointer]
-    line_to_pointer = (@completion_journey_data.preposing + completed).split("\n")[@line_index] || String.new(encoding: @encoding)
-    new_line = line_to_pointer + (@completion_journey_data.postposing.split("\n").first || '')
-    set_current_line(new_line, line_to_pointer.bytesize)
+    completed = @completion_journey_state.list[@completion_journey_state.pointer]
+    set_current_line(@completion_journey_state.pre + completed + @completion_journey_state.post, @completion_journey_state.pre.bytesize + completed.bytesize)
+    true
+  end
+
+  private def retrieve_completion_journey_state
+    preposing, target, postposing = retrieve_completion_block
+    list = call_completion_proc
+    return unless list.is_a?(Array)
+
+    candidates = list.select{ |item| item.start_with?(target) }
+    return if candidates.empty?
+
+    pre = preposing.split("\n", -1).last || ''
+    post = postposing.split("\n", -1).first || ''
+    CompletionJourneyState.new(
+      @line_index, pre, target, post, [target] + candidates, 0
+    )
   end
 
   private def run_for_operators(key, method_symbol, &block)
@@ -1122,59 +1120,65 @@ class Reline::LineEditor
     @first_char = false
     completion_occurs = false
     if @config.editing_mode_is?(:emacs, :vi_insert) and key.char == "\C-i".ord
-      unless @config.disable_completion
-        result = call_completion_proc
-        if result.is_a?(Array)
-          completion_occurs = true
-          process_insert
-          if @config.autocompletion
-            move_completed_list(result, :down)
-          else
-            complete(result)
+      if !@config.disable_completion
+        process_insert(force: true)
+        if @config.autocompletion
+          @completion_state = CompletionState::NORMAL
+          completion_occurs = move_completed_list(:down)
+        else
+          @completion_journey_state = nil
+          result = call_completion_proc
+          if result.is_a?(Array)
+            completion_occurs = true
+            complete(result, false)
           end
         end
       end
     elsif @config.editing_mode_is?(:emacs, :vi_insert) and key.char == :completion_journey_up
       if not @config.disable_completion and @config.autocompletion
-        result = call_completion_proc
-        if result.is_a?(Array)
-          completion_occurs = true
-          process_insert
-          move_completed_list(result, :up)
-        end
+        process_insert(force: true)
+        @completion_state = CompletionState::NORMAL
+        completion_occurs = move_completed_list(:up)
       end
-    elsif not @config.disable_completion and @config.editing_mode_is?(:vi_insert) and ["\C-p".ord, "\C-n".ord].include?(key.char)
-      unless @config.disable_completion
-        result = call_completion_proc
-        if result.is_a?(Array)
-          completion_occurs = true
-          process_insert
-          move_completed_list(result, "\C-p".ord == key.char ? :up : :down)
-        end
+    elsif @config.editing_mode_is?(:vi_insert) and ["\C-p".ord, "\C-n".ord].include?(key.char)
+      # In vi mode, move completed list even if autocompletion is off
+      if not @config.disable_completion
+        process_insert(force: true)
+        @completion_state = CompletionState::NORMAL
+        completion_occurs = move_completed_list("\C-p".ord == key.char ? :up : :down)
       end
     elsif Symbol === key.char and respond_to?(key.char, true)
       process_key(key.char, key.char)
     else
       normal_char(key)
     end
+
     unless completion_occurs
       @completion_state = CompletionState::NORMAL
-      @completion_journey_data = nil
+      @completion_journey_state = nil
     end
+
     if @in_pasting
       clear_dialogs
-    else
-      return old_lines != @buffer_of_lines
+      return
     end
+
+    modified = old_lines != @buffer_of_lines
+    if !completion_occurs && modified && !@config.disable_completion && @config.autocompletion
+      # Auto complete starts only when edited
+      process_insert(force: true)
+      @completion_journey_state = retrieve_completion_journey_state
+    end
+    modified
   end
 
   def scroll_into_view
-    _editor_cursor_x, editor_cursor_y = editor_cursor_position
-    if editor_cursor_y < screen_scroll_top
-      @scroll_partial_screen = editor_cursor_y
+    _wrapped_cursor_x, wrapped_cursor_y = wrapped_cursor_position
+    if wrapped_cursor_y < screen_scroll_top
+      @scroll_partial_screen = wrapped_cursor_y
     end
-    if editor_cursor_y >= screen_scroll_top + screen_height
-      @scroll_partial_screen = editor_cursor_y - screen_height + 1
+    if wrapped_cursor_y >= screen_scroll_top + screen_height
+      @scroll_partial_screen = wrapped_cursor_y - screen_height + 1
     end
   end
 
@@ -1217,10 +1221,11 @@ class Reline::LineEditor
     new_indent = @auto_indent_proc.(@buffer_of_lines.take(line_index + 1).push(''), line_index, byte_pointer, add_newline)
     return unless new_indent
 
-    @buffer_of_lines[line_index] = ' ' * new_indent + line.lstrip
+    new_line = ' ' * new_indent + line.lstrip
+    @buffer_of_lines[line_index] = new_line
     if @line_index == line_index
-      old_indent = line[/\A */].size
-      @byte_pointer = [@byte_pointer + new_indent - old_indent, 0].max
+      indent_diff = new_line.bytesize - line.bytesize
+      @byte_pointer = [@byte_pointer + indent_diff, 0].max
     end
   end
 
@@ -1233,7 +1238,6 @@ class Reline::LineEditor
   end
 
   def set_current_line(line, byte_pointer = nil)
-    @modified = true
     cursor = current_byte_pointer_cursor
     @buffer_of_lines[@line_index] = line
     if byte_pointer
@@ -1993,6 +1997,13 @@ class Reline::LineEditor
   end
   alias_method :kill_line, :ed_kill_line
 
+  # Editline:: +vi_change_to_eol+ (vi command: +C+) + Kill and change from the cursor to the end of the line.
+  private def vi_change_to_eol(key)
+    ed_kill_line(key)
+
+    @config.editing_mode = :vi_insert
+  end
+
   # Editline:: +vi-kill-line-prev+ (vi: +Ctrl-U+) Delete the string from the
   #            beginning  of the edit buffer to the cursor and save it to the
   #            cut buffer.
@@ -2037,7 +2048,7 @@ class Reline::LineEditor
   private def em_delete_or_list(key)
     if current_line.empty? or @byte_pointer < current_line.bytesize
       em_delete(key)
-    else # show completed list
+    elsif !@config.autocompletion # show completed list
       result = call_completion_proc
       if result.is_a?(Array)
         complete(result, true)
@@ -2063,7 +2074,11 @@ class Reline::LineEditor
   alias_method :yank_pop, :em_yank_pop
 
   private def ed_clear_screen(key)
-    @cleared = true
+    Reline::IOGate.clear_screen
+    @screen_size = Reline::IOGate.get_screen_size
+    @rendered_screen.lines = []
+    @rendered_screen.base_y = 0
+    @rendered_screen.cursor_y = 0
   end
   alias_method :clear_screen, :ed_clear_screen
 
@@ -2291,7 +2306,7 @@ class Reline::LineEditor
   end
 
   private def ed_delete_prev_char(key, arg: 1)
-    deleted = ''
+    deleted = +''
     arg.times do
       if @byte_pointer > 0
         byte_size = Reline::Unicode.get_prev_mbchar_size(current_line, @byte_pointer)

data/lib/reline/terminfo.rb

@@ -80,23 +80,11 @@ module Reline::Terminfo
   def self.setupterm(term, fildes)
     errret_int = Fiddle::Pointer.malloc(Fiddle::SIZEOF_INT)
     ret = @setupterm.(term, fildes, errret_int)
-    errret = errret_int[0, Fiddle::SIZEOF_INT].unpack1('i')
     case ret
     when 0 # OK
-      0
+      @term_supported = true
     when -1 # ERR
-      case errret
-      when 1
-        raise TerminfoError.new('The terminal is hardcopy, cannot be used for curses applications.')
-      when 0
-        raise TerminfoError.new('The terminal could not be found, or that it is a generic type, having too little information for curses applications to run.')
-      when -1
-        raise TerminfoError.new('The terminfo database could not be found.')
-      else # unknown
-        -1
-      end
-    else # unknown
-      -2
+      @term_supported = false
     end
   end
 
@@ -148,9 +136,14 @@ module Reline::Terminfo
     num
   end
 
+  # NOTE: This means Fiddle and curses are enabled.
   def self.enabled?
     true
   end
+
+  def self.term_supported?
+    @term_supported
+  end
 end if Reline::Terminfo.curses_dl
 
 module Reline::Terminfo

data/lib/reline/version.rb

@@ -1,3 +1,3 @@
 module Reline
-  VERSION = '0.5.0.pre.1'
+  VERSION = '0.5.1'
 end

data/lib/reline/windows.rb

@@ -1,6 +1,8 @@
 require 'fiddle/import'
 
 class Reline::Windows
+  RESET_COLOR = "\e[0m"
+
   def self.encoding
     Encoding::UTF_8
   end
@@ -85,7 +87,7 @@ class Reline::Windows
       def call(*args)
         import = @proto.split("")
         args.each_with_index do |x, i|
-          args[i], = [x == 0 ? nil : x].pack("p").unpack(POINTER_TYPE) if import[i] == "S"
+          args[i], = [x == 0 ? nil : +x].pack("p").unpack(POINTER_TYPE) if import[i] == "S"
           args[i], = [x].pack("I").unpack("i") if import[i] == "I"
         end
         ret, = @func.call(*args)
@@ -257,7 +259,7 @@ class Reline::Windows
   def self.check_input_event
     num_of_events = 0.chr * 8
     while @@output_buf.empty?
-      Reline.core.line_editor.resize
+      Reline.core.line_editor.handle_signal
       if @@WaitForSingleObject.(@@hConsoleInputHandle, 100) != 0 # max 0.1 sec
         # prevent for background consolemode change
         @@legacy_console = (getconsolemode() & ENABLE_VIRTUAL_TERMINAL_PROCESSING == 0)

data/lib/reline.rb

@@ -75,10 +75,10 @@ module Reline
 
     def initialize
       self.output = STDOUT
+      @mutex = Mutex.new
       @dialog_proc_list = {}
       yield self
       @completion_quote_character = nil
-      @bracketed_paste_finished = false
     end
 
     def io_gate
@@ -220,26 +220,16 @@ module Reline
 
     Reline::DEFAULT_DIALOG_PROC_AUTOCOMPLETE = ->() {
       # autocomplete
-      return nil unless config.autocompletion
-      if just_cursor_moving and completion_journey_data.nil?
-        # Auto complete starts only when edited
-        return nil
-      end
-      pre, target, post = retrieve_completion_block(true)
-      if target.nil? or target.empty? or (completion_journey_data&.pointer == -1 and target.size <= 3)
-        return nil
-      end
-      if completion_journey_data and completion_journey_data.list
-        result = completion_journey_data.list.dup
-        result.shift
-        pointer = completion_journey_data.pointer - 1
-      else
-        result = call_completion_proc_with_checking_args(pre, target, post)
-        pointer = nil
-      end
-      if result and result.size == 1 and result[0] == target and pointer != 0
-        result = nil
-      end
+      return unless config.autocompletion
+
+      journey_data = completion_journey_data
+      return unless journey_data
+
+      target = journey_data.list[journey_data.pointer]
+      result = journey_data.list.drop(1)
+      pointer = journey_data.pointer - 1
+      return if target.empty? || (result == [target] && pointer < 0)
+
       target_width = Reline::Unicode.calculate_width(target)
       x = cursor_pos.x - target_width
       if x < 0
@@ -265,12 +255,15 @@ module Reline
     Reline::DEFAULT_DIALOG_CONTEXT = Array.new
 
     def readmultiline(prompt = '', add_hist = false, &confirm_multiline_termination)
-      Reline.update_iogate
-      io_gate.with_raw_input do
+      @mutex.synchronize do
         unless confirm_multiline_termination
           raise ArgumentError.new('#readmultiline needs block to confirm multiline termination')
         end
-        inner_readline(prompt, add_hist, true, &confirm_multiline_termination)
+
+        Reline.update_iogate
+        io_gate.with_raw_input do
+          inner_readline(prompt, add_hist, true, &confirm_multiline_termination)
+        end
 
         whole_buffer = line_editor.whole_buffer.dup
         whole_buffer.taint if RUBY_VERSION < '2.7'
@@ -280,6 +273,7 @@ module Reline
 
         if line_editor.eof?
           line_editor.reset_line
+          # Return nil if the input is aborted by C-d.
           nil
         else
           whole_buffer
@@ -288,17 +282,21 @@ module Reline
     end
 
     def readline(prompt = '', add_hist = false)
-      Reline.update_iogate
-      inner_readline(prompt, add_hist, false)
+      @mutex.synchronize do
+        Reline.update_iogate
+        io_gate.with_raw_input do
+          inner_readline(prompt, add_hist, false)
+        end
 
-      line = line_editor.line.dup
-      line.taint if RUBY_VERSION < '2.7'
-      if add_hist and line and line.chomp("\n").size > 0
-        Reline::HISTORY << line.chomp("\n")
-      end
+        line = line_editor.line.dup
+        line.taint if RUBY_VERSION < '2.7'
+        if add_hist and line and line.chomp("\n").size > 0
+          Reline::HISTORY << line.chomp("\n")
+        end
 
-      line_editor.reset_line if line_editor.line.nil?
-      line
+        line_editor.reset_line if line_editor.line.nil?
+        line
+      end
     end
 
     private def inner_readline(prompt, add_hist, multiline, &confirm_multiline_termination)
@@ -331,8 +329,10 @@ module Reline
       line_editor.auto_indent_proc = auto_indent_proc
       line_editor.dig_perfect_match_proc = dig_perfect_match_proc
       pre_input_hook&.call
-      @dialog_proc_list.each_pair do |name_sym, d|
-        line_editor.add_dialog_proc(name_sym, d.dialog_proc, d.context)
+      unless Reline::IOGate == Reline::GeneralIO
+        @dialog_proc_list.each_pair do |name_sym, d|
+          line_editor.add_dialog_proc(name_sym, d.dialog_proc, d.context)
+        end
       end
 
       unless config.test_mode
@@ -342,45 +342,31 @@ module Reline
       end
 
       line_editor.print_nomultiline_prompt(prompt)
+      line_editor.update_dialogs
       line_editor.rerender
 
       begin
         line_editor.set_signal_handlers
-        prev_pasting_state = false
         loop do
-          prev_pasting_state = io_gate.in_pasting?
           read_io(config.keyseq_timeout) { |inputs|
             line_editor.set_pasting_state(io_gate.in_pasting?)
-            inputs.each { |c| line_editor.update(c) }
-            line_editor.rerender
-            if @bracketed_paste_finished
-              line_editor.rerender_all
-              @bracketed_paste_finished = false
-            end
+            inputs.each { |key| line_editor.update(key) }
           }
-          if prev_pasting_state == true and not io_gate.in_pasting? and not line_editor.finished?
-            line_editor.set_pasting_state(false)
-            prev_pasting_state = false
-            line_editor.rerender_all
+          if line_editor.finished?
+            line_editor.render_finished
+            break
+          else
+            line_editor.set_pasting_state(io_gate.in_pasting?)
+            line_editor.rerender
           end
-          break if line_editor.finished?
         end
         io_gate.move_cursor_column(0)
       rescue Errno::EIO
         # Maybe the I/O has been closed.
-      rescue StandardError => e
+      ensure
         line_editor.finalize
         io_gate.deprep(otio)
-        raise e
-      rescue Exception
-        # Including Interrupt
-        line_editor.finalize
-        io_gate.deprep(otio)
-        raise
       end
-
-      line_editor.finalize
-      io_gate.deprep(otio)
     end
 
     # GNU Readline waits for "keyseq-timeout" milliseconds to see if the ESC
@@ -398,7 +384,6 @@ module Reline
         c = io_gate.getc(Float::INFINITY)
         if c == -1
           result = :unmatched
-          @bracketed_paste_finished = true
         else
           buffer << c
           result = key_stroke.match_status(buffer)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: reline
 version: !ruby/object:Gem::Version
-  version: 0.5.0.pre.1
+  version: 0.5.1
 platform: ruby
 authors:
 - aycabta
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-12-01 00:00:00.000000000 Z
+date: 2024-04-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: io-console
@@ -57,7 +57,10 @@ files:
 homepage: https://github.com/ruby/reline
 licenses:
 - Ruby
-metadata: {}
+metadata:
+  bug_tracker_uri: https://github.com/ruby/reline/issues
+  changelog_uri: https://github.com/ruby/reline/releases
+  source_code_uri: https://github.com/ruby/reline
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -69,11 +72,11 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: Alternative GNU Readline or Editline implementation by pure Ruby.