reline 0.5.7 → 0.5.9

data/lib/reline/key_stroke.rb

@@ -7,138 +7,99 @@ class Reline::KeyStroke
     @config = config
   end
 
-  def compress_meta_key(ary)
-    return ary unless @config.convert_meta
-    ary.inject([]) { |result, key|
-      if result.size > 0 and result.last == "\e".ord
-        result[result.size - 1] = Reline::Key.new(key, key | 0b10000000, true)
-      else
-        result << key
-      end
-      result
-    }
-  end
+  # Input exactly matches to a key sequence
+  MATCHING = :matching
+  # Input partially matches to a key sequence
+  MATCHED = :matched
+  # Input matches to a key sequence and the key sequence is a prefix of another key sequence
+  MATCHING_MATCHED = :matching_matched
+  # Input does not match to any key sequence
+  UNMATCHED = :unmatched
 
-  def start_with?(me, other)
-    compressed_me = compress_meta_key(me)
-    compressed_other = compress_meta_key(other)
-    i = 0
-    loop do
-      my_c = compressed_me[i]
-      other_c = compressed_other[i]
-      other_is_last = (i + 1) == compressed_other.size
-      me_is_last = (i + 1) == compressed_me.size
-      if my_c != other_c
-        if other_c == "\e".ord and other_is_last and my_c.is_a?(Reline::Key) and my_c.with_meta
-          return true
-        else
-          return false
-        end
-      elsif other_is_last
-        return true
-      elsif me_is_last
-        return false
-      end
-      i += 1
-    end
-  end
+  def match_status(input)
+    matching = key_mapping.matching?(input)
+    matched = key_mapping.get(input)
 
-  def equal?(me, other)
-    case me
-    when Array
-      compressed_me = compress_meta_key(me)
-      compressed_other = compress_meta_key(other)
-      compressed_me.size == compressed_other.size and [compressed_me, compressed_other].transpose.all?{ |i| equal?(i[0], i[1]) }
-    when Integer
-      if other.is_a?(Reline::Key)
-        if other.combined_char == "\e".ord
-          false
-        else
-          other.combined_char == me
-        end
-      else
-        me == other
-      end
-    when Reline::Key
-      if other.is_a?(Integer)
-        me.combined_char == other
-      else
-        me == other
-      end
-    end
-  end
+    # FIXME: Workaround for single byte. remove this after MAPPING is merged into KeyActor.
+    matched ||= input.size == 1
+    matching ||= input == [ESC_BYTE]
 
-  def match_status(input)
-    key_mapping.keys.select { |lhs|
-      start_with?(lhs, input)
-    }.tap { |it|
-      return :matched  if it.size == 1 && equal?(it[0], input)
-      return :matching if it.size == 1 && !equal?(it[0], input)
-      return :matched  if it.max_by(&:size)&.size&.< input.size
-      return :matching if it.size > 1
-    }
-    if key_mapping.keys.any? { |lhs| start_with?(input, lhs) }
-      :matched
+    if matching && matched
+      MATCHING_MATCHED
+    elsif matching
+      MATCHING
+    elsif matched
+      MATCHED
+    elsif input[0] == ESC_BYTE
+      match_unknown_escape_sequence(input, vi_mode: @config.editing_mode_is?(:vi_insert, :vi_command))
+    elsif input.size == 1
+      MATCHED
     else
-      match_unknown_escape_sequence(input).first
+      UNMATCHED
     end
   end
 
   def expand(input)
-    lhs = key_mapping.keys.select { |item| start_with?(input, item) }.sort_by(&:size).last
-    unless lhs
-      status, size = match_unknown_escape_sequence(input)
-      case status
-      when :matched
-        return [:ed_unassigned] + expand(input.drop(size))
-      when :matching
-        return [:ed_unassigned]
-      else
-        return input
-      end
+    matched_bytes = nil
+    (1..input.size).each do |i|
+      bytes = input.take(i)
+      status = match_status(bytes)
+      matched_bytes = bytes if status == MATCHED || status == MATCHING_MATCHED
     end
-    rhs = key_mapping[lhs]
+    return [[], []] unless matched_bytes
 
-    case rhs
-    when String
-      rhs_bytes = rhs.bytes
-      expand(expand(rhs_bytes) + expand(input.drop(lhs.size)))
-    when Symbol
-      [rhs] + expand(input.drop(lhs.size))
-    when Array
-      rhs
+    func = key_mapping.get(matched_bytes)
+    if func.is_a?(Array)
+      keys = func.map { |c| Reline::Key.new(c, c, false) }
+    elsif func
+      keys = [Reline::Key.new(func, func, false)]
+    elsif matched_bytes.size == 1
+      keys = [Reline::Key.new(matched_bytes.first, matched_bytes.first, false)]
+    elsif matched_bytes.size == 2 && matched_bytes[0] == ESC_BYTE
+      keys = [Reline::Key.new(matched_bytes[1], matched_bytes[1] | 0b10000000, true)]
+    else
+      keys = []
     end
+
+    [keys, input.drop(matched_bytes.size)]
   end
 
   private
 
   # returns match status of CSI/SS3 sequence and matched length
-  def match_unknown_escape_sequence(input)
+  def match_unknown_escape_sequence(input, vi_mode: false)
     idx = 0
-    return [:unmatched, nil] unless input[idx] == ESC_BYTE
+    return UNMATCHED unless input[idx] == ESC_BYTE
     idx += 1
     idx += 1 if input[idx] == ESC_BYTE
 
     case input[idx]
     when nil
-      return [:matching, nil]
+      if idx == 1 # `ESC`
+        return MATCHING_MATCHED
+      else # `ESC ESC`
+        return MATCHING
+      end
     when 91 # == '['.ord
-      # CSI sequence
+      # CSI sequence `ESC [ ... char`
       idx += 1
       idx += 1 while idx < input.size && CSI_PARAMETER_BYTES_RANGE.cover?(input[idx])
       idx += 1 while idx < input.size && CSI_INTERMEDIATE_BYTES_RANGE.cover?(input[idx])
-      input[idx] ? [:matched, idx + 1] : [:matching, nil]
     when 79 # == 'O'.ord
-      # SS3 sequence
-      input[idx + 1] ? [:matched, idx + 2] : [:matching, nil]
+      # SS3 sequence `ESC O char`
+      idx += 1
     else
-      if idx == 1
-        # `ESC char`, make it :unmatched so that it will be handled correctly in `read_2nd_character_of_key_sequence`
-        [:unmatched, nil]
-      else
-        # `ESC ESC char`
-        [:matched, idx + 1]
-      end
+      # `ESC char` or `ESC ESC char`
+      return UNMATCHED if vi_mode
+    end
+
+    case input.size
+    when idx
+      MATCHING
+    when idx + 1
+      MATCHED
+    else
+      UNMATCHED
     end
   end
 

data/lib/reline/line_editor.rb

@@ -45,6 +45,7 @@ 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
@@ -237,7 +238,6 @@ class Reline::LineEditor
     @perfect_matched = nil
     @menu_info = nil
     @searching_prompt = nil
-    @first_char = true
     @just_cursor_moving = false
     @eof = false
     @continuous_insertion_buffer = String.new(encoding: @encoding)
@@ -250,8 +250,11 @@ class Reline::LineEditor
     @resized = false
     @cache = {}
     @rendered_screen = RenderedScreen.new(base_y: 0, lines: [], cursor_y: 0)
-    @past_lines = []
+    @input_lines = [[[""], 0, 0]]
+    @input_lines_position = 0
     @undoing = false
+    @prev_action_state = NullActionState
+    @next_action_state = NullActionState
     reset_line
   end
 
@@ -411,7 +414,7 @@ class Reline::LineEditor
         # do nothing
       elsif level == :blank
         Reline::IOGate.move_cursor_column base_x
-        @output.write "#{Reline::IOGate::RESET_COLOR}#{' ' * width}"
+        @output.write "#{Reline::IOGate.reset_color_sequence}#{' ' * width}"
       else
         x, w, content = new_items[level]
         cover_begin = base_x != 0 && new_levels[base_x - 1] == level
@@ -421,7 +424,7 @@ class Reline::LineEditor
           content, pos = Reline::Unicode.take_mbchar_range(content, base_x - x, width, cover_begin: cover_begin, cover_end: cover_end, padding: true)
         end
         Reline::IOGate.move_cursor_column x + pos
-        @output.write "#{Reline::IOGate::RESET_COLOR}#{content}#{Reline::IOGate::RESET_COLOR}"
+        @output.write "#{Reline::IOGate.reset_color_sequence}#{content}#{Reline::IOGate.reset_color_sequence}"
       end
       base_x += width
     end
@@ -683,10 +686,8 @@ class Reline::LineEditor
           @trap_key.each do |t|
             @config.add_oneshot_key_binding(t, @name)
           end
-        elsif @trap_key.is_a?(Array)
+        else
           @config.add_oneshot_key_binding(@trap_key, @name)
-        elsif @trap_key.is_a?(Integer) or @trap_key.is_a?(Reline::Key)
-          @config.add_oneshot_key_binding([@trap_key], @name)
         end
       end
       dialog_render_info
@@ -1079,17 +1080,7 @@ class Reline::LineEditor
     else # single byte
       return if key.char >= 128 # maybe, first byte of multi byte
       method_symbol = @config.editing_mode.get_method(key.combined_char)
-      if key.with_meta and method_symbol == :ed_unassigned
-        if @config.editing_mode_is?(:vi_command, :vi_insert)
-          # split ESC + key in vi mode
-          method_symbol = @config.editing_mode.get_method("\e".ord)
-          process_key("\e".ord, method_symbol)
-          method_symbol = @config.editing_mode.get_method(key.char)
-          process_key(key.char, method_symbol)
-        end
-      else
-        process_key(key.combined_char, method_symbol)
-      end
+      process_key(key.combined_char, method_symbol)
       @multibyte_buffer.clear
     end
     if @config.editing_mode_is?(:vi_command) and @byte_pointer > 0 and @byte_pointer == current_line.bytesize
@@ -1118,13 +1109,10 @@ class Reline::LineEditor
     end
     if key.char.nil?
       process_insert(force: true)
-      if @first_char
-        @eof = true
-      end
+      @eof = buffer_empty?
       finish
       return
     end
-    @first_char = false
     @completion_occurs = false
 
     if key.char.is_a?(Symbol)
@@ -1132,12 +1120,15 @@ class Reline::LineEditor
     else
       normal_char(key)
     end
+
+    @prev_action_state, @next_action_state = @next_action_state, NullActionState
+
     unless @completion_occurs
       @completion_state = CompletionState::NORMAL
       @completion_journey_state = nil
     end
 
-    push_past_lines unless @undoing
+    push_input_lines unless @undoing
     @undoing = false
 
     if @in_pasting
@@ -1156,21 +1147,24 @@ class Reline::LineEditor
 
   def save_old_buffer
     @old_buffer_of_lines = @buffer_of_lines.dup
-    @old_byte_pointer = @byte_pointer.dup
-    @old_line_index = @line_index.dup
   end
 
-  def push_past_lines
-    if @old_buffer_of_lines != @buffer_of_lines
-      @past_lines.push([@old_buffer_of_lines, @old_byte_pointer, @old_line_index])
+  def push_input_lines
+    if @old_buffer_of_lines == @buffer_of_lines
+      @input_lines[@input_lines_position] = [@buffer_of_lines.dup, @byte_pointer, @line_index]
+    else
+      @input_lines = @input_lines[0..@input_lines_position]
+      @input_lines_position += 1
+      @input_lines.push([@buffer_of_lines.dup, @byte_pointer, @line_index])
     end
-    trim_past_lines
+    trim_input_lines
   end
 
-  MAX_PAST_LINES = 100
-  def trim_past_lines
-    if @past_lines.size > MAX_PAST_LINES
-      @past_lines.shift
+  MAX_INPUT_LINES = 100
+  def trim_input_lines
+    if @input_lines.size > MAX_INPUT_LINES
+      @input_lines.shift
+      @input_lines_position -= 1
     end
   end
 
@@ -1352,7 +1346,7 @@ class Reline::LineEditor
     @buffer_of_lines[@line_index, 1] = lines
     @line_index += lines.size - 1
     @byte_pointer = @buffer_of_lines[@line_index].bytesize - post.bytesize
-    push_past_lines
+    push_input_lines
   end
 
   def insert_text(text)
@@ -1411,6 +1405,10 @@ class Reline::LineEditor
     whole_lines.join("\n")
   end
 
+  private def buffer_empty?
+    current_line.empty? and @buffer_of_lines.size == 1
+  end
+
   def finished?
     @finished
   end
@@ -1759,29 +1757,31 @@ class Reline::LineEditor
   end
 
   private def ed_search_prev_history(key, arg: 1)
-    substr = current_line.byteslice(0, @byte_pointer)
+    substr = prev_action_state_value(:search_history) == :empty ? '' : current_line.byteslice(0, @byte_pointer)
     return if @history_pointer == 0
     return if @history_pointer.nil? && substr.empty? && !current_line.empty?
 
     history_range = 0...(@history_pointer || Reline::HISTORY.size)
     h_pointer, line_index = search_history(substr, history_range.reverse_each)
     return unless h_pointer
-    move_history(h_pointer, line: line_index || :start, cursor: @byte_pointer)
+    move_history(h_pointer, line: line_index || :start, cursor: substr.empty? ? :end : @byte_pointer)
     arg -= 1
+    set_next_action_state(:search_history, :empty) if substr.empty?
     ed_search_prev_history(key, arg: arg) if arg > 0
   end
   alias_method :history_search_backward, :ed_search_prev_history
 
   private def ed_search_next_history(key, arg: 1)
-    substr = current_line.byteslice(0, @byte_pointer)
+    substr = prev_action_state_value(:search_history) == :empty ? '' : current_line.byteslice(0, @byte_pointer)
     return if @history_pointer.nil?
 
     history_range = @history_pointer + 1...Reline::HISTORY.size
     h_pointer, line_index = search_history(substr, history_range)
     return if h_pointer.nil? and not substr.empty?
 
-    move_history(h_pointer, line: line_index || :start, cursor: @byte_pointer)
+    move_history(h_pointer, line: line_index || :start, cursor: substr.empty? ? :end : @byte_pointer)
     arg -= 1
+    set_next_action_state(:search_history, :empty) if substr.empty?
     ed_search_next_history(key, arg: arg) if arg > 0
   end
   alias_method :history_search_forward, :ed_search_next_history
@@ -1937,7 +1937,7 @@ class Reline::LineEditor
   alias_method :kill_whole_line, :em_kill_line
 
   private def em_delete(key)
-    if current_line.empty? and @buffer_of_lines.size == 1 and key == "\C-d".ord
+    if buffer_empty? and key == "\C-d".ord
       @eof = true
       finish
     elsif @byte_pointer < current_line.bytesize
@@ -2285,8 +2285,7 @@ class Reline::LineEditor
   end
 
   private def vi_list_or_eof(key)
-    if current_line.empty? and @buffer_of_lines.size == 1
-      set_current_line('', 0)
+    if buffer_empty?
       @eof = true
       finish
     else
@@ -2529,13 +2528,30 @@ class Reline::LineEditor
   end
 
   private def undo(_key)
-    return if @past_lines.empty?
+    @undoing = true
+
+    return if @input_lines_position <= 0
+
+    @input_lines_position -= 1
+    target_lines, target_cursor_x, target_cursor_y = @input_lines[@input_lines_position]
+    set_current_lines(target_lines.dup, target_cursor_x, target_cursor_y)
+  end
 
+  private def redo(_key)
     @undoing = true
 
-    target_lines, target_cursor_x, target_cursor_y = @past_lines.last
-    set_current_lines(target_lines, target_cursor_x, target_cursor_y)
+    return if @input_lines_position >= @input_lines.size - 1
+
+    @input_lines_position += 1
+    target_lines, target_cursor_x, target_cursor_y = @input_lines[@input_lines_position]
+    set_current_lines(target_lines.dup, target_cursor_x, target_cursor_y)
+  end
+
+  private def prev_action_state_value(type)
+    @prev_action_state[0] == type ? @prev_action_state[1] : nil
+  end
 
-    @past_lines.pop
+  private def set_next_action_state(type, value)
+    @next_action_state = [type, value]
   end
 end

data/lib/reline/terminfo.rb

@@ -1,4 +1,7 @@
 begin
+  # Ignore warning `Add fiddle to your Gemfile or gemspec` in Ruby 3.4.
+  # terminfo.rb and ansi.rb supports fiddle unavailable environment.
+  verbose, $VERBOSE = $VERBOSE, nil
   require 'fiddle'
   require 'fiddle/import'
 rescue LoadError
@@ -7,6 +10,8 @@ rescue LoadError
       false
     end
   end
+ensure
+  $VERBOSE = verbose
 end
 
 module Reline::Terminfo

data/lib/reline/version.rb

@@ -1,3 +1,3 @@
 module Reline
-  VERSION = '0.5.7'
+  VERSION = '0.5.9'
 end