reline 0.3.3 → 0.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b0fe224245c6f66bdfa42b7fd6b0dc4c30f9645f0c1498fd7780ff17db642eec
-  data.tar.gz: af1b5a53e09f4b2c60ae20e153a4b3043ea3a19a38c58be697067c58f63feec7
+  metadata.gz: 3654e31f9c5d1aa879ae40dfb28b8de68f2e443fac87856f2387a22d61a5b4e7
+  data.tar.gz: 0fdccab5b7cfd91274e3e4544dcca69a442176cc85e1eba382da3ffd02f9ac30
 SHA512:
-  metadata.gz: cb456e06f2cef817fe3ae8fa27e9666587f2b3175cdbc97714ab3638d5b11bf606595d772c4e100fc21d9f50ed6e55fb6b833c28bad6b4ae3c8838d2418e75f5
-  data.tar.gz: 6f3eb2f3feee78d7b4754c069a7d6c0d5d29af100bcb493bab2696c9b610c86de4fb3b201d624b6d00f218f1257a526d0c29bf95c79a1ed3daf117f0c95a2768
+  metadata.gz: 9277033707e4a1531e8590ae6a76019c21c60da22f69ea333dcc5c3d3610499303ed7892308b6ae3b495237738344baac7a21c547a19ff77f53fecae29be9a14
+  data.tar.gz: 5f3f225d7b1ee1f0ab067d8a897366a3d3b922dcedb74ae3ec980e387ad3b520d8ab808f70d89e109d06f7e5017ab6406d30e25ed2b6678b3fc8d6c4d5cf6930

data/README.md

@@ -1,4 +1,5 @@
-[![Build Status](https://travis-ci.com/ruby/reline.svg?branch=master)](https://travis-ci.com/ruby/reline)
+[![Gem Version](https://badge.fury.io/rb/reline.svg)](https://badge.fury.io/rb/reline)
+[![CI](https://github.com/ruby/reline/actions/workflows/reline.yml/badge.svg)](https://github.com/ruby/reline/actions/workflows/reline.yml)
 
 This is a screen capture of *IRB improved by Reline*.
 

data/lib/reline/line_editor.rb

@@ -94,7 +94,7 @@ class Reline::LineEditor
     mode_string
   end
 
-  private def check_multiline_prompt(buffer)
+  private def check_multiline_prompt(buffer, force_recalc: false)
     if @vi_arg
       prompt = "(arg: #{@vi_arg}) "
       @rerender_all = true
@@ -104,7 +104,7 @@ class Reline::LineEditor
     else
       prompt = @prompt
     end
-    if simplified_rendering?
+    if simplified_rendering? && !force_recalc
       mode_string = check_mode_string
       prompt = mode_string + prompt if mode_string
       return [prompt, calculate_width(prompt, true), [prompt] * buffer.size]
@@ -220,7 +220,7 @@ class Reline::LineEditor
 
   def set_signal_handlers
     @old_trap = Signal.trap('INT') {
-      clear_dialog
+      clear_dialog(0)
       if @scroll_partial_screen
         move_cursor_down(@screen_height - (@line_index - @scroll_partial_screen) - 1)
       else
@@ -239,21 +239,10 @@ class Reline::LineEditor
         @old_trap.call if @old_trap.respond_to?(:call)
       end
     }
-    begin
-      @old_tstp_trap = Signal.trap('TSTP') {
-        Reline::IOGate.ungetc("\C-z".ord)
-        @old_tstp_trap.call if @old_tstp_trap.respond_to?(:call)
-      }
-    rescue ArgumentError
-    end
   end
 
   def finalize
     Signal.trap('INT', @old_trap)
-    begin
-      Signal.trap('TSTP', @old_tstp_trap)
-    rescue ArgumentError
-    end
   end
 
   def eof?
@@ -294,6 +283,7 @@ class Reline::LineEditor
     @in_pasting = false
     @auto_indent_proc = nil
     @dialogs = []
+    @previous_rendered_dialog_y = 0
     @last_key = nil
     @resized = false
     reset_line
@@ -440,6 +430,7 @@ class Reline::LineEditor
       @menu_info = nil
     end
     prompt, prompt_width, prompt_list = check_multiline_prompt(whole_lines)
+    cursor_column = (prompt_width + @cursor) % @screen_size.last
     if @cleared
       clear_screen_buffer(prompt, prompt_list, prompt_width)
       @cleared = false
@@ -457,23 +448,23 @@ class Reline::LineEditor
         Reline::IOGate.erase_after_cursor
       end
       @output.flush
-      clear_dialog
+      clear_dialog(cursor_column)
       return
     end
     new_highest_in_this = calculate_height_by_width(prompt_width + calculate_width(@line.nil? ? '' : @line))
     rendered = false
     if @add_newline_to_end_of_buffer
-      clear_dialog_with_content
+      clear_dialog_with_trap_key(cursor_column)
       rerender_added_newline(prompt, prompt_width, prompt_list)
       @add_newline_to_end_of_buffer = false
     else
       if @just_cursor_moving and not @rerender_all
-        clear_dialog_with_content
+        clear_dialog_with_trap_key(cursor_column)
         rendered = just_move_cursor
         @just_cursor_moving = false
         return
       elsif @previous_line_index or new_highest_in_this != @highest_in_this
-        clear_dialog_with_content
+        clear_dialog_with_trap_key(cursor_column)
         rerender_changed_current_line
         @previous_line_index = nil
         rendered = true
@@ -489,7 +480,7 @@ class Reline::LineEditor
         # Always rerender on finish because output_modifier_proc may return a different output.
         new_lines = whole_lines
         line = modify_lines(new_lines)[@line_index]
-        clear_dialog
+        clear_dialog(cursor_column)
         prompt, prompt_width, prompt_list = check_multiline_prompt(new_lines)
         render_partial(prompt, prompt_width, line, @first_line_started_from)
         move_cursor_down(@highest_in_all - (@first_line_started_from + @highest_in_this - 1) - 1)
@@ -502,7 +493,7 @@ class Reline::LineEditor
           prompt, prompt_width, prompt_list = check_multiline_prompt(whole_lines)
           render_partial(prompt, prompt_width, line, @first_line_started_from)
         end
-        render_dialog((prompt_width + @cursor) % @screen_size.last)
+        render_dialog(cursor_column)
       end
       @buffer_of_lines[@line_index] = @line
       @rest_height = 0 if @scroll_partial_screen
@@ -571,6 +562,16 @@ class Reline::LineEditor
       @line_editor.instance_variable_get(:@screen_size).last
     end
 
+    def screen_height
+      @line_editor.instance_variable_get(:@screen_size).first
+    end
+
+    def preferred_dialog_height
+      rest_height = @line_editor.instance_variable_get(:@rest_height)
+      scroll_partial_screen = @line_editor.instance_variable_get(:@scroll_partial_screen) || 0
+      [cursor_pos.y - scroll_partial_screen, rest_height, (screen_height + 6) / 5].max
+    end
+
     def completion_journey_data
       @line_editor.instance_variable_get(:@completion_journey_data)
     end
@@ -586,7 +587,7 @@ class Reline::LineEditor
 
   class Dialog
     attr_reader :name, :contents, :width
-    attr_accessor :scroll_top, :scrollbar_pos, :pointer, :column, :vertical_offset, :lines_backup, :trap_key
+    attr_accessor :scroll_top, :pointer, :column, :vertical_offset, :trap_key
 
     def initialize(name, config, proc_scope)
       @name = name
@@ -642,9 +643,12 @@ class Reline::LineEditor
 
   DIALOG_DEFAULT_HEIGHT = 20
   private def render_dialog(cursor_column)
-    @dialogs.each do |dialog|
-      render_each_dialog(dialog, cursor_column)
+    changes = @dialogs.map do |dialog|
+      old_dialog = dialog.dup
+      update_each_dialog(dialog, cursor_column)
+      [old_dialog, dialog]
     end
+    render_dialog_changes(changes, cursor_column)
   end
 
   private def padding_space_with_escape_sequences(str, width)
@@ -654,9 +658,112 @@ class Reline::LineEditor
     str + (' ' * padding_width)
   end
 
-  private def render_each_dialog(dialog, cursor_column)
+  private def range_subtract(base_ranges, subtract_ranges)
+    indices = base_ranges.flat_map(&:to_a).uniq.sort - subtract_ranges.flat_map(&:to_a)
+    chunks = indices.chunk_while { |a, b| a + 1 == b }
+    chunks.map { |a| a.first...a.last + 1 }
+  end
+
+  private def dialog_range(dialog, dialog_y)
+    x_range = dialog.column...dialog.column + dialog.width
+    y_range = dialog_y + dialog.vertical_offset...dialog_y + dialog.vertical_offset + dialog.contents.size
+    [x_range, y_range]
+  end
+
+  private def render_dialog_changes(changes, cursor_column)
+    # Collect x-coordinate range and content of previous and current dialogs for each line
+    old_dialog_ranges = {}
+    new_dialog_ranges = {}
+    new_dialog_contents = {}
+    changes.each do |old_dialog, new_dialog|
+      if old_dialog.contents
+        x_range, y_range = dialog_range(old_dialog, @previous_rendered_dialog_y)
+        y_range.each do |y|
+          (old_dialog_ranges[y] ||= []) << x_range
+        end
+      end
+      if new_dialog.contents
+        x_range, y_range = dialog_range(new_dialog, @first_line_started_from + @started_from)
+        y_range.each do |y|
+          (new_dialog_ranges[y] ||= []) << x_range
+          (new_dialog_contents[y] ||= []) << [x_range, new_dialog.contents[y - y_range.begin]]
+        end
+      end
+    end
+    return if old_dialog_ranges.empty? && new_dialog_ranges.empty?
+
+    # Calculate x-coordinate ranges to restore text that was hidden behind dialogs for each line
+    ranges_to_restore = {}
+    subtract_cache = {}
+    old_dialog_ranges.each do |y, old_x_ranges|
+      new_x_ranges = new_dialog_ranges[y] || []
+      ranges = subtract_cache[[old_x_ranges, new_x_ranges]] ||= range_subtract(old_x_ranges, new_x_ranges)
+      ranges_to_restore[y] = ranges if ranges.any?
+    end
+
+    # Create visual_lines for restoring text hidden behind dialogs
+    if ranges_to_restore.any?
+      lines = whole_lines
+      prompt, _prompt_width, prompt_list = check_multiline_prompt(lines, force_recalc: true)
+      modified_lines = modify_lines(lines, force_recalc: true)
+      visual_lines = []
+      modified_lines.each_with_index { |l, i|
+        pr = prompt_list ? prompt_list[i] : prompt
+        vl, = split_by_width(pr + l, @screen_size.last)
+        vl.compact!
+        visual_lines.concat(vl)
+      }
+    end
+
+    # Clear and rerender all dialogs line by line
+    Reline::IOGate.hide_cursor
+    ymin, ymax = (ranges_to_restore.keys + new_dialog_ranges.keys).minmax
+    scroll_partial_screen = @scroll_partial_screen || 0
+    screen_y_range = scroll_partial_screen..(scroll_partial_screen + @screen_height - 1)
+    ymin = ymin.clamp(screen_y_range.begin, screen_y_range.end)
+    ymax = ymax.clamp(screen_y_range.begin, screen_y_range.end)
+    dialog_y = @first_line_started_from + @started_from
+    cursor_y = dialog_y
+    if @highest_in_all <= ymax
+      scroll_down(ymax - cursor_y)
+      move_cursor_up(ymax - cursor_y)
+    end
+    (ymin..ymax).each do |y|
+      move_cursor_down(y - cursor_y)
+      cursor_y = y
+      new_x_ranges = new_dialog_ranges[y]
+      restore_ranges = ranges_to_restore[y]
+      # Restore text that was hidden behind dialogs
+      if restore_ranges
+        line = visual_lines[y] || ''
+        restore_ranges.each do |range|
+          col = range.begin
+          width = range.end - range.begin
+          s = padding_space_with_escape_sequences(Reline::Unicode.take_range(line, col, width), width)
+          Reline::IOGate.move_cursor_column(col)
+          @output.write "\e[0m#{s}\e[0m"
+        end
+        max_column = [calculate_width(line, true), new_x_ranges&.map(&:end)&.max || 0].max
+        if max_column < restore_ranges.map(&:end).max
+          Reline::IOGate.move_cursor_column(max_column)
+          Reline::IOGate.erase_after_cursor
+        end
+      end
+      # Render dialog contents
+      new_dialog_contents[y]&.each do |x_range, content|
+        Reline::IOGate.move_cursor_column(x_range.begin)
+        @output.write "\e[0m#{content}\e[0m"
+      end
+    end
+    move_cursor_up(cursor_y - dialog_y)
+    Reline::IOGate.move_cursor_column(cursor_column)
+    Reline::IOGate.show_cursor
+
+    @previous_rendered_dialog_y = dialog_y
+  end
+
+  private def update_each_dialog(dialog, cursor_column)
     if @in_pasting
-      clear_each_dialog(dialog)
       dialog.contents = nil
       dialog.trap_key = nil
       return
@@ -664,31 +771,20 @@ class Reline::LineEditor
     dialog.set_cursor_pos(cursor_column, @first_line_started_from + @started_from)
     dialog_render_info = dialog.call(@last_key)
     if dialog_render_info.nil? or dialog_render_info.contents.nil? or dialog_render_info.contents.empty?
-      lines = whole_lines
-      dialog.lines_backup = {
-        unmodified_lines: lines,
-        lines: modify_lines(lines),
-        line_index: @line_index,
-        first_line_started_from: @first_line_started_from,
-        started_from: @started_from,
-        byte_pointer: @byte_pointer
-      }
-      clear_each_dialog(dialog)
       dialog.contents = nil
       dialog.trap_key = nil
       return
     end
-    old_dialog = dialog.clone
-    dialog.contents = dialog_render_info.contents
+    contents = dialog_render_info.contents
     pointer = dialog.pointer
     if dialog_render_info.width
       dialog.width = dialog_render_info.width
     else
-      dialog.width = dialog.contents.map { |l| calculate_width(l, true) }.max
+      dialog.width = contents.map { |l| calculate_width(l, true) }.max
     end
     height = dialog_render_info.height || DIALOG_DEFAULT_HEIGHT
-    height = dialog.contents.size if dialog.contents.size < height
-    if dialog.contents.size > height
+    height = contents.size if contents.size < height
+    if contents.size > height
       if dialog.pointer
         if dialog.pointer < 0
           dialog.scroll_top = 0
@@ -701,21 +797,21 @@ class Reline::LineEditor
       else
         dialog.scroll_top = 0
       end
-      dialog.contents = dialog.contents[dialog.scroll_top, height]
+      contents = contents[dialog.scroll_top, height]
     end
     if dialog_render_info.scrollbar and dialog_render_info.contents.size > height
       bar_max_height = height * 2
       moving_distance = (dialog_render_info.contents.size - height) * 2
       position_ratio = dialog.scroll_top.zero? ? 0.0 : ((dialog.scroll_top * 2).to_f / moving_distance)
-      bar_height = (bar_max_height * ((dialog.contents.size * 2).to_f / (dialog_render_info.contents.size * 2))).floor.to_i
+      bar_height = (bar_max_height * ((contents.size * 2).to_f / (dialog_render_info.contents.size * 2))).floor.to_i
       bar_height = MINIMUM_SCROLLBAR_HEIGHT if bar_height < MINIMUM_SCROLLBAR_HEIGHT
-      dialog.scrollbar_pos = ((bar_max_height - bar_height) * position_ratio).floor.to_i
+      scrollbar_pos = ((bar_max_height - bar_height) * position_ratio).floor.to_i
     else
-      dialog.scrollbar_pos = nil
+      scrollbar_pos = nil
     end
     upper_space = @first_line_started_from - @started_from
     dialog.column = dialog_render_info.pos.x
-    dialog.width += @block_elem_width if dialog.scrollbar_pos
+    dialog.width += @block_elem_width if scrollbar_pos
     diff = (dialog.column + dialog.width) - (@screen_size.last)
     if diff > 0
       dialog.column -= diff
@@ -725,21 +821,13 @@ class Reline::LineEditor
     elsif upper_space >= height
       dialog.vertical_offset = dialog_render_info.pos.y - height
     else
-      if (@rest_height - dialog_render_info.pos.y) < height
-        scroll_down(height + dialog_render_info.pos.y)
-        move_cursor_up(height + dialog_render_info.pos.y)
-      end
       dialog.vertical_offset = dialog_render_info.pos.y + 1
     end
-    Reline::IOGate.hide_cursor
     if dialog.column < 0
       dialog.column = 0
       dialog.width = @screen_size.last
     end
-    reset_dialog(dialog, old_dialog)
-    move_cursor_down(dialog.vertical_offset)
-    Reline::IOGate.move_cursor_column(dialog.column)
-    dialog.contents.each_with_index do |item, i|
+    dialog.contents = contents.map.with_index do |item, i|
       if i == pointer
         fg_color = dialog_render_info.pointer_fg_color
         bg_color = dialog_render_info.pointer_bg_color
@@ -747,187 +835,42 @@ class Reline::LineEditor
         fg_color = dialog_render_info.fg_color
         bg_color = dialog_render_info.bg_color
       end
-      str_width = dialog.width - (dialog.scrollbar_pos.nil? ? 0 : @block_elem_width)
+      str_width = dialog.width - (scrollbar_pos.nil? ? 0 : @block_elem_width)
       str = padding_space_with_escape_sequences(Reline::Unicode.take_range(item, 0, str_width), str_width)
-      @output.write "\e[#{bg_color}m\e[#{fg_color}m#{str}"
-      if dialog.scrollbar_pos
-        @output.write "\e[37m"
-        if dialog.scrollbar_pos <= (i * 2) and (i * 2 + 1) < (dialog.scrollbar_pos + bar_height)
-          @output.write @full_block
-        elsif dialog.scrollbar_pos <= (i * 2) and (i * 2) < (dialog.scrollbar_pos + bar_height)
-          @output.write @upper_half_block
-        elsif dialog.scrollbar_pos <= (i * 2 + 1) and (i * 2) < (dialog.scrollbar_pos + bar_height)
-          @output.write @lower_half_block
-        else
-          @output.write ' ' * @block_elem_width
-        end
-      end
-      @output.write "\e[0m"
-      Reline::IOGate.move_cursor_column(dialog.column)
-      move_cursor_down(1) if i < (dialog.contents.size - 1)
-    end
-    Reline::IOGate.move_cursor_column(cursor_column)
-    move_cursor_up(dialog.vertical_offset + dialog.contents.size - 1)
-    Reline::IOGate.show_cursor
-    lines = whole_lines
-    dialog.lines_backup = {
-      unmodified_lines: lines,
-      lines: modify_lines(lines),
-      line_index: @line_index,
-      first_line_started_from: @first_line_started_from,
-      started_from: @started_from,
-      byte_pointer: @byte_pointer
-    }
-  end
-
-  private def reset_dialog(dialog, old_dialog)
-    return if dialog.lines_backup.nil? or old_dialog.contents.nil?
-    prompt, prompt_width, prompt_list = check_multiline_prompt(dialog.lines_backup[:unmodified_lines])
-    visual_lines = []
-    visual_start = nil
-    dialog.lines_backup[:lines].each_with_index { |l, i|
-      pr = prompt_list ? prompt_list[i] : prompt
-      vl, _ = split_by_width(pr + l, @screen_size.last)
-      vl.compact!
-      if i == dialog.lines_backup[:line_index]
-        visual_start = visual_lines.size + dialog.lines_backup[:started_from]
-      end
-      visual_lines.concat(vl)
-    }
-    old_y = dialog.lines_backup[:first_line_started_from] + dialog.lines_backup[:started_from]
-    y = @first_line_started_from + @started_from
-    y_diff = y - old_y
-    if (old_y + old_dialog.vertical_offset) < (y + dialog.vertical_offset)
-      # rerender top
-      move_cursor_down(old_dialog.vertical_offset - y_diff)
-      start = visual_start + old_dialog.vertical_offset
-      line_num = dialog.vertical_offset - old_dialog.vertical_offset
-      line_num.times do |i|
-        Reline::IOGate.move_cursor_column(old_dialog.column)
-        if visual_lines[start + i].nil?
-          s = ' ' * old_dialog.width
-        else
-          s = Reline::Unicode.take_range(visual_lines[start + i], old_dialog.column, old_dialog.width)
-          s = padding_space_with_escape_sequences(s, old_dialog.width)
-        end
-        @output.write "\e[0m#{s}\e[0m"
-        move_cursor_down(1) if i < (line_num - 1)
-      end
-      move_cursor_up(old_dialog.vertical_offset + line_num - 1 - y_diff)
-    end
-    if (old_y + old_dialog.vertical_offset + old_dialog.contents.size) > (y + dialog.vertical_offset + dialog.contents.size)
-      # rerender bottom
-      move_cursor_down(dialog.vertical_offset + dialog.contents.size - y_diff)
-      start = visual_start + dialog.vertical_offset + dialog.contents.size
-      line_num = (old_dialog.vertical_offset + old_dialog.contents.size) - (dialog.vertical_offset + dialog.contents.size)
-      line_num.times do |i|
-        Reline::IOGate.move_cursor_column(old_dialog.column)
-        if visual_lines[start + i].nil?
-          s = ' ' * old_dialog.width
-        else
-          s = Reline::Unicode.take_range(visual_lines[start + i], old_dialog.column, old_dialog.width)
-          s = padding_space_with_escape_sequences(s, old_dialog.width)
-        end
-        @output.write "\e[0m#{s}\e[0m"
-        move_cursor_down(1) if i < (line_num - 1)
-      end
-      move_cursor_up(dialog.vertical_offset + dialog.contents.size + line_num - 1 - y_diff)
-    end
-    if old_dialog.column < dialog.column
-      # rerender left
-      move_cursor_down(old_dialog.vertical_offset - y_diff)
-      width = dialog.column - old_dialog.column
-      start = visual_start + old_dialog.vertical_offset
-      line_num = old_dialog.contents.size
-      line_num.times do |i|
-        Reline::IOGate.move_cursor_column(old_dialog.column)
-        if visual_lines[start + i].nil?
-          s = ' ' * width
-        else
-          s = Reline::Unicode.take_range(visual_lines[start + i], old_dialog.column, width)
-          s = padding_space_with_escape_sequences(s, dialog.width)
-        end
-        @output.write "\e[0m#{s}\e[0m"
-        move_cursor_down(1) if i < (line_num - 1)
-      end
-      move_cursor_up(old_dialog.vertical_offset + line_num - 1 - y_diff)
-    end
-    if (old_dialog.column + old_dialog.width) > (dialog.column + dialog.width)
-      # rerender right
-      move_cursor_down(old_dialog.vertical_offset + y_diff)
-      width = (old_dialog.column + old_dialog.width) - (dialog.column + dialog.width)
-      start = visual_start + old_dialog.vertical_offset
-      line_num = old_dialog.contents.size
-      line_num.times do |i|
-        Reline::IOGate.move_cursor_column(old_dialog.column + dialog.width)
-        if visual_lines[start + i].nil?
-          s = ' ' * width
+      colored_content = "\e[#{bg_color}m\e[#{fg_color}m#{str}"
+      if scrollbar_pos
+        color_seq = "\e[37m"
+        if scrollbar_pos <= (i * 2) and (i * 2 + 1) < (scrollbar_pos + bar_height)
+          colored_content + color_seq + @full_block
+        elsif scrollbar_pos <= (i * 2) and (i * 2) < (scrollbar_pos + bar_height)
+          colored_content + color_seq + @upper_half_block
+        elsif scrollbar_pos <= (i * 2 + 1) and (i * 2) < (scrollbar_pos + bar_height)
+          colored_content + color_seq + @lower_half_block
         else
-          s = Reline::Unicode.take_range(visual_lines[start + i], old_dialog.column + dialog.width, width)
-          rerender_width = old_dialog.width - dialog.width
-          s = padding_space_with_escape_sequences(s, rerender_width)
+          colored_content + color_seq + ' ' * @block_elem_width
         end
-        Reline::IOGate.move_cursor_column(dialog.column + dialog.width)
-        @output.write "\e[0m#{s}\e[0m"
-        move_cursor_down(1) if i < (line_num - 1)
+      else
+        colored_content
       end
-      move_cursor_up(old_dialog.vertical_offset + line_num - 1 + y_diff)
     end
-    Reline::IOGate.move_cursor_column((prompt_width + @cursor) % @screen_size.last)
   end
 
-  private def clear_dialog
-    @dialogs.each do |dialog|
-      clear_each_dialog(dialog)
+  private def clear_dialog(cursor_column)
+    changes = @dialogs.map do |dialog|
+      old_dialog = dialog.dup
+      dialog.contents = nil
+      [old_dialog, dialog]
     end
+    render_dialog_changes(changes, cursor_column)
   end
 
-  private def clear_dialog_with_content
+  private def clear_dialog_with_trap_key(cursor_column)
+    clear_dialog(cursor_column)
     @dialogs.each do |dialog|
-      clear_each_dialog(dialog)
-      dialog.contents = nil
       dialog.trap_key = nil
     end
   end
 
-  private def clear_each_dialog(dialog)
-    dialog.trap_key = nil
-    return unless dialog.contents
-    prompt, prompt_width, prompt_list = check_multiline_prompt(dialog.lines_backup[:unmodified_lines])
-    visual_lines = []
-    visual_lines_under_dialog = []
-    visual_start = nil
-    dialog.lines_backup[:lines].each_with_index { |l, i|
-      pr = prompt_list ? prompt_list[i] : prompt
-      vl, _ = split_by_width(pr + l, @screen_size.last)
-      vl.compact!
-      if i == dialog.lines_backup[:line_index]
-        visual_start = visual_lines.size + dialog.lines_backup[:started_from] + dialog.vertical_offset
-      end
-      visual_lines.concat(vl)
-    }
-    visual_lines_under_dialog = visual_lines[visual_start, dialog.contents.size]
-    visual_lines_under_dialog = [] if visual_lines_under_dialog.nil?
-    Reline::IOGate.hide_cursor
-    move_cursor_down(dialog.vertical_offset)
-    dialog_vertical_size = dialog.contents.size
-    dialog_vertical_size.times do |i|
-      if i < visual_lines_under_dialog.size
-        Reline::IOGate.move_cursor_column(dialog.column)
-        str = Reline::Unicode.take_range(visual_lines_under_dialog[i], dialog.column, dialog.width)
-        str = padding_space_with_escape_sequences(str, dialog.width)
-        @output.write "\e[0m#{str}\e[0m"
-      else
-        Reline::IOGate.move_cursor_column(dialog.column)
-        @output.write "\e[0m#{' ' * dialog.width}\e[0m"
-      end
-      move_cursor_down(1) if i < (dialog_vertical_size - 1)
-    end
-    move_cursor_up(dialog_vertical_size - 1 + dialog.vertical_offset)
-    Reline::IOGate.move_cursor_column((prompt_width + @cursor) % @screen_size.last)
-    Reline::IOGate.show_cursor
-  end
-
   private def calculate_scroll_partial_screen(highest_in_all, cursor_y)
     if @screen_height < highest_in_all
       old_scroll_partial_screen = @scroll_partial_screen
@@ -1235,8 +1178,8 @@ class Reline::LineEditor
     height
   end
 
-  private def modify_lines(before)
-    return before if before.nil? || before.empty? || simplified_rendering?
+  private def modify_lines(before, force_recalc: false)
+    return before if !force_recalc && (before.nil? || before.empty? || simplified_rendering?)
 
     if after = @output_modifier_proc&.call("#{before.join("\n")}\n", complete: finished?)
       after.lines("\n").map { |l| l.chomp('') }

data/lib/reline/terminfo.rb

@@ -31,21 +31,7 @@ module Reline::Terminfo
   @curses_dl = false
   def self.curses_dl
     return @curses_dl unless @curses_dl == false
-    if RUBY_VERSION >= '3.0.0'
-      # Gem module isn't defined in test-all of the Ruby repository, and
-      # Fiddle in Ruby 3.0.0 or later supports Fiddle::TYPE_VARIADIC.
-      fiddle_supports_variadic = true
-    elsif Fiddle.const_defined?(:VERSION,false) and Gem::Version.create(Fiddle::VERSION) >= Gem::Version.create('1.0.1')
-      # Fiddle::TYPE_VARIADIC is supported from Fiddle 1.0.1.
-      fiddle_supports_variadic = true
-    else
-      fiddle_supports_variadic = false
-    end
-    if fiddle_supports_variadic and not Fiddle.const_defined?(:TYPE_VARIADIC)
-      # If the libffi version is not 3.0.5 or higher, there isn't TYPE_VARIADIC.
-      fiddle_supports_variadic = false
-    end
-    if fiddle_supports_variadic
+    if Fiddle.const_defined?(:TYPE_VARIADIC)
       curses_dl_files.each do |curses_name|
         result = Fiddle::Handle.new(curses_name)
       rescue Fiddle::DLError

data/lib/reline/unicode.rb

@@ -38,13 +38,8 @@ class Reline::Unicode
   NON_PRINTING_START = "\1"
   NON_PRINTING_END = "\2"
   CSI_REGEXP = /\e\[[\d;]*[ABCDEFGHJKSTfminsuhl]/
-  OSC_REGEXP = /\e\]\d+(?:;[^;]+)*\a/
+  OSC_REGEXP = /\e\]\d+(?:;[^;\a\e]+)*(?:\a|\e\\)/
   WIDTH_SCANNER = /\G(?:(#{NON_PRINTING_START})|(#{NON_PRINTING_END})|(#{CSI_REGEXP})|(#{OSC_REGEXP})|(\X))/o
-  NON_PRINTING_START_INDEX = 0
-  NON_PRINTING_END_INDEX = 1
-  CSI_REGEXP_INDEX = 2
-  OSC_REGEXP_INDEX = 3
-  GRAPHEME_CLUSTER_INDEX = 4
 
   def self.get_mbchar_byte_size_by_first_char(c)
     # Checks UTF-8 character byte size
@@ -132,15 +127,14 @@ class Reline::Unicode
       width = 0
       rest = str.encode(Encoding::UTF_8)
       in_zero_width = false
-      rest.scan(WIDTH_SCANNER) do |gc|
+      rest.scan(WIDTH_SCANNER) do |non_printing_start, non_printing_end, csi, osc, gc|
         case
-        when gc[NON_PRINTING_START_INDEX]
+        when non_printing_start
           in_zero_width = true
-        when gc[NON_PRINTING_END_INDEX]
+        when non_printing_end
           in_zero_width = false
-        when gc[CSI_REGEXP_INDEX], gc[OSC_REGEXP_INDEX]
-        when gc[GRAPHEME_CLUSTER_INDEX]
-          gc = gc[GRAPHEME_CLUSTER_INDEX]
+        when csi, osc
+        when gc
           unless in_zero_width
             width += get_mbchar_width(gc)
           end
@@ -161,22 +155,21 @@ class Reline::Unicode
     rest = str.encode(Encoding::UTF_8)
     in_zero_width = false
     seq = String.new(encoding: encoding)
-    rest.scan(WIDTH_SCANNER) do |gc|
+    rest.scan(WIDTH_SCANNER) do |non_printing_start, non_printing_end, csi, osc, gc|
       case
-      when gc[NON_PRINTING_START_INDEX]
+      when non_printing_start
         in_zero_width = true
         lines.last << NON_PRINTING_START
-      when gc[NON_PRINTING_END_INDEX]
+      when non_printing_end
         in_zero_width = false
         lines.last << NON_PRINTING_END
-      when gc[CSI_REGEXP_INDEX]
-        lines.last << gc[CSI_REGEXP_INDEX]
-        seq << gc[CSI_REGEXP_INDEX]
-      when gc[OSC_REGEXP_INDEX]
-        lines.last << gc[OSC_REGEXP_INDEX]
-        seq << gc[OSC_REGEXP_INDEX]
-      when gc[GRAPHEME_CLUSTER_INDEX]
-        gc = gc[GRAPHEME_CLUSTER_INDEX]
+      when csi
+        lines.last << csi
+        seq << csi
+      when osc
+        lines.last << osc
+        seq << osc
+      when gc
         unless in_zero_width
           mbchar_width = get_mbchar_width(gc)
           if (width += mbchar_width) > max_width
@@ -199,23 +192,22 @@ class Reline::Unicode
   end
 
   # Take a chunk of a String cut by width with escape sequences.
-  def self.take_range(str, start_col, max_width, encoding = str.encoding)
-    chunk = String.new(encoding: encoding)
+  def self.take_range(str, start_col, max_width)
+    chunk = String.new(encoding: str.encoding)
     total_width = 0
     rest = str.encode(Encoding::UTF_8)
     in_zero_width = false
-    rest.scan(WIDTH_SCANNER) do |gc|
+    rest.scan(WIDTH_SCANNER) do |non_printing_start, non_printing_end, csi, osc, gc|
       case
-      when gc[NON_PRINTING_START_INDEX]
+      when non_printing_start
         in_zero_width = true
-      when gc[NON_PRINTING_END_INDEX]
+      when non_printing_end
         in_zero_width = false
-      when gc[CSI_REGEXP_INDEX]
-        chunk << gc[CSI_REGEXP_INDEX]
-      when gc[OSC_REGEXP_INDEX]
-        chunk << gc[OSC_REGEXP_INDEX]
-      when gc[GRAPHEME_CLUSTER_INDEX]
-        gc = gc[GRAPHEME_CLUSTER_INDEX]
+      when csi
+        chunk << csi
+      when osc
+        chunk << osc
+      when gc
         if in_zero_width
           chunk << gc
         else

data/lib/reline/version.rb

@@ -1,3 +1,3 @@
 module Reline
-  VERSION = '0.3.3'
+  VERSION = '0.3.5'
 end

data/lib/reline.rb

@@ -166,9 +166,13 @@ module Reline
 
     DialogProc = Struct.new(:dialog_proc, :context)
     def add_dialog_proc(name_sym, p, context = nil)
-      raise ArgumentError unless p.respond_to?(:call) or p.nil?
       raise ArgumentError unless name_sym.instance_of?(Symbol)
-      @dialog_proc_list[name_sym] = DialogProc.new(p, context)
+      if p.nil?
+        @dialog_proc_list.delete(name_sym)
+      else
+        raise ArgumentError unless p.respond_to?(:call)
+        @dialog_proc_list[name_sym] = DialogProc.new(p, context)
+      end
     end
 
     def dialog_proc(name_sym)
@@ -256,7 +260,7 @@ module Reline
         pos: cursor_pos_to_render,
         contents: result,
         scrollbar: true,
-        height: 15,
+        height: [15, preferred_dialog_height].min,
         bg_color: 46,
         pointer_bg_color: 45,
         fg_color: 37,

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: reline
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.3.5
 platform: ruby
 authors:
 - aycabta
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-03-27 00:00:00.000000000 Z
+date: 2023-06-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: io-console
@@ -72,7 +72,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.8
+rubygems_version: 3.4.13
 signing_key:
 specification_version: 4
 summary: Alternative GNU Readline or Editline implementation by pure Ruby.