reline 0.5.11 → 0.5.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d2e17ec5d6de83746c38c5e0764f7fa1ecda40f01c18b9e8cdf769e4bf2a155e
-  data.tar.gz: 7ce06466fae4c8115bb507141998d322595b9e924dfc1ad3001871265088a680
+  metadata.gz: 14c0b8843530985ab335eb7dbb365d72708214a67b5a858d75d0aebe605050c3
+  data.tar.gz: ba60692647a18e520d1b8ed0fff6ac44b11048b3c8f2f2050a5651955db21c89
 SHA512:
-  metadata.gz: 31e90ffea6ac235aad5c2c243fbd41163142f94e044ed9f4980860263fab97154857483755dcacd259fa9b578b1c29be5b878cd7f883f18e7b92380cb5865ef3
-  data.tar.gz: 54b91a893c536b3e6b5c984c0fc2b053b8978ab586ae361446fb603c4eecfb0240a99c45b25e4996ff58d9ef15fa4e33bab5cef9cb4aef3dc7eab85998af3711
+  metadata.gz: 242efcf7910a3981d12f7238df77b20d8c0a4fffb735bc59d53f8662e8fbb149d53c8081adf03bbb2b237f576a6f942ba66f01d6b46e1de29617fb29edb89a58
+  data.tar.gz: 9d80fef9e52a79300e6163b9dd5141fe412fc3caa32f108f9158108d54abef6ec23b93fc018afd5efdf374c38713e0973afe06adbbe148cae457ca45dd7024b7

data/lib/reline/io/ansi.rb

@@ -29,10 +29,6 @@ class Reline::ANSI < Reline::IO
     'H' => [:ed_move_to_beg, {}],
   }
 
-  if Reline::Terminfo.enabled?
-    Reline::Terminfo.setupterm(0, 2)
-  end
-
   def initialize
     @input = STDIN
     @output = STDOUT
@@ -42,16 +38,15 @@ class Reline::ANSI < Reline::IO
 
   def encoding
     @input.external_encoding || Encoding.default_external
+  rescue IOError
+    # STDIN.external_encoding raises IOError in Ruby <= 3.0 when STDIN is closed
+    Encoding.default_external
   end
 
-  def set_default_key_bindings(config, allow_terminfo: true)
+  def set_default_key_bindings(config)
     set_bracketed_paste_key_bindings(config)
     set_default_key_bindings_ansi_cursor(config)
-    if allow_terminfo && Reline::Terminfo.enabled?
-      set_default_key_bindings_terminfo(config)
-    else
-      set_default_key_bindings_comprehensive_list(config)
-    end
+    set_default_key_bindings_comprehensive_list(config)
     {
       [27, 91, 90] => :completion_journey_up, # S-Tab
     }.each_pair do |key, func|
@@ -98,23 +93,6 @@ class Reline::ANSI < Reline::IO
     end
   end
 
-  def set_default_key_bindings_terminfo(config)
-    key_bindings = CAPNAME_KEY_BINDINGS.map do |capname, key_binding|
-      begin
-        key_code = Reline::Terminfo.tigetstr(capname)
-        [ key_code.bytes, key_binding ]
-      rescue Reline::Terminfo::TerminfoError
-        # capname is undefined
-      end
-    end.compact.to_h
-
-    key_bindings.each_pair do |key, func|
-      config.add_default_key_binding_by_keymap(:emacs, key, func)
-      config.add_default_key_binding_by_keymap(:vi_insert, key, func)
-      config.add_default_key_binding_by_keymap(:vi_command, key, func)
-    end
-  end
-
   def set_default_key_bindings_comprehensive_list(config)
     {
       # xterm
@@ -281,27 +259,11 @@ class Reline::ANSI < Reline::IO
   end
 
   def hide_cursor
-    seq = "\e[?25l"
-    if Reline::Terminfo.enabled? && Reline::Terminfo.term_supported?
-      begin
-        seq = Reline::Terminfo.tigetstr('civis')
-      rescue Reline::Terminfo::TerminfoError
-        # civis is undefined
-      end
-    end
-    @output.write seq
+    @output.write "\e[?25l"
   end
 
   def show_cursor
-    seq = "\e[?25h"
-    if Reline::Terminfo.enabled? && Reline::Terminfo.term_supported?
-      begin
-        seq = Reline::Terminfo.tigetstr('cnorm')
-      rescue Reline::Terminfo::TerminfoError
-        # cnorm is undefined
-      end
-    end
-    @output.write seq
+    @output.write "\e[?25h"
   end
 
   def erase_after_cursor

data/lib/reline/io/dumb.rb

@@ -21,8 +21,11 @@ class Reline::Dumb < Reline::IO
     elsif RUBY_PLATFORM =~ /mswin|mingw/
       Encoding::UTF_8
     else
-      @input.external_encoding || Encoding::default_external
+      @input.external_encoding || Encoding.default_external
     end
+  rescue IOError
+    # STDIN.external_encoding raises IOError in Ruby <= 3.0 when STDIN is closed
+    Encoding.default_external
   end
 
   def set_default_key_bindings(_)

data/lib/reline/key_stroke.rb

@@ -3,8 +3,11 @@ class Reline::KeyStroke
   CSI_PARAMETER_BYTES_RANGE = 0x30..0x3f
   CSI_INTERMEDIATE_BYTES_RANGE = (0x20..0x2f)
 
-  def initialize(config)
+  attr_accessor :encoding
+
+  def initialize(config, encoding)
     @config = config
+    @encoding = encoding
   end
 
   # Input exactly matches to a key sequence
@@ -21,7 +24,7 @@ class Reline::KeyStroke
     matched = key_mapping.get(input)
 
     # FIXME: Workaround for single byte. remove this after MAPPING is merged into KeyActor.
-    matched ||= input.size == 1
+    matched ||= input.size == 1 && input[0] < 0x80
     matching ||= input == [ESC_BYTE]
 
     if matching && matched
@@ -32,10 +35,14 @@ class Reline::KeyStroke
       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
-      UNMATCHED
+      s = input.pack('c*').force_encoding(@encoding)
+      if s.valid_encoding?
+        s.size == 1 ? MATCHED : UNMATCHED
+      else
+        # Invalid string is MATCHING (part of valid string) or MATCHED (invalid bytes to be ignored)
+        MATCHING_MATCHED
+      end
     end
   end
 
@@ -45,6 +52,7 @@ class Reline::KeyStroke
       bytes = input.take(i)
       status = match_status(bytes)
       matched_bytes = bytes if status == MATCHED || status == MATCHING_MATCHED
+      break if status == MATCHED || status == UNMATCHED
     end
     return [[], []] unless matched_bytes
 
@@ -53,12 +61,15 @@ class Reline::KeyStroke
       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 = []
+      s = matched_bytes.pack('c*').force_encoding(@encoding)
+      if s.valid_encoding? && s.size == 1
+        keys = [Reline::Key.new(s.ord, s.ord, false)]
+      else
+        keys = []
+      end
     end
 
     [keys, input.drop(matched_bytes.size)]

data/lib/reline/line_editor.rb

@@ -36,7 +36,6 @@ class Reline::LineEditor
 
   module CompletionState
     NORMAL = :normal
-    COMPLETION = :completion
     MENU = :menu
     MENU_WITH_PERFECT_MATCH = :menu_with_perfect_match
     PERFECT_MATCH = :perfect_match
@@ -266,7 +265,6 @@ class Reline::LineEditor
     @line_index = 0
     @cache.clear
     @line_backup_in_history = nil
-    @multibyte_buffer = String.new(encoding: 'ASCII-8BIT')
   end
 
   def multiline_on
@@ -300,8 +298,8 @@ class Reline::LineEditor
     end
   end
 
-  private def split_by_width(str, max_width, offset: 0)
-    Reline::Unicode.split_by_width(str, max_width, encoding, offset: offset)
+  private def split_line_by_width(str, max_width, offset: 0)
+    Reline::Unicode.split_line_by_width(str, max_width, encoding, offset: offset)
   end
 
   def current_byte_pointer_cursor
@@ -391,8 +389,8 @@ class Reline::LineEditor
         if (cached = cached_wraps[[prompt, line]])
           next cached
         end
-        *wrapped_prompts, code_line_prompt = split_by_width(prompt, width).first.compact
-        wrapped_lines = split_by_width(line, width, offset: calculate_width(code_line_prompt, true)).first.compact
+        *wrapped_prompts, code_line_prompt = split_line_by_width(prompt, width)
+        wrapped_lines = split_line_by_width(line, width, offset: calculate_width(code_line_prompt, true))
         wrapped_prompts.map { |p| [p, ''] } + [[code_line_prompt, wrapped_lines.first]] + wrapped_lines.drop(1).map { |c| ['', c] }
       end
     end
@@ -440,7 +438,7 @@ class Reline::LineEditor
   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_line_before_cursor = split_line_by_width(' ' * prompt_width + line_before_cursor, screen_width)
     wrapped_cursor_y = wrapped_prompt_and_input_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]
@@ -465,7 +463,7 @@ class Reline::LineEditor
     render_differential([], 0, 0)
     lines = @buffer_of_lines.size.times.map do |i|
       line = Reline::Unicode.strip_non_printing_start_end(prompt_list[i]) + modified_lines[i]
-      wrapped_lines, = split_by_width(line, screen_width)
+      wrapped_lines = split_line_by_width(line, screen_width)
       wrapped_lines.last.empty? ? "#{line} " : line
     end
     @output.puts lines.map { |l| "#{l}\r\n" }.join
@@ -579,8 +577,9 @@ class Reline::LineEditor
       @context
     end
 
-    def retrieve_completion_block(set_completion_quote_character = false)
-      @line_editor.retrieve_completion_block(set_completion_quote_character)
+    def retrieve_completion_block(_unused = false)
+      preposing, target, postposing, _quote = @line_editor.retrieve_completion_block
+      [preposing, target, postposing]
     end
 
     def call_completion_proc_with_checking_args(pre, target, post)
@@ -800,105 +799,73 @@ class Reline::LineEditor
     @config.editing_mode
   end
 
-  private def menu(_target, list)
+  private def menu(list)
     @menu_info = MenuInfo.new(list)
   end
 
-  private def complete_internal_proc(list, is_menu)
-    preposing, target, postposing = retrieve_completion_block
-    candidates = list.select { |i|
-      if i and not Encoding.compatible?(target.encoding, i.encoding)
-        raise Encoding::CompatibilityError, "#{target.encoding.name} is not compatible with #{i.encoding.name}"
+  private def filter_normalize_candidates(target, list)
+    target = target.downcase if @config.completion_ignore_case
+    list.select do |item|
+      next unless item
+
+      unless Encoding.compatible?(target.encoding, item.encoding)
+        # Crash with Encoding::CompatibilityError is required by readline-ext/test/readline/test_readline.rb
+        # TODO: fix the test
+        raise Encoding::CompatibilityError, "#{target.encoding.name} is not compatible with #{item.encoding.name}"
       end
+
       if @config.completion_ignore_case
-        i&.downcase&.start_with?(target.downcase)
+        item.downcase.start_with?(target)
       else
-        i&.start_with?(target)
+        item.start_with?(target)
       end
-    }.uniq
-    if is_menu
-      menu(target, candidates)
-      return nil
-    end
-    completed = candidates.inject { |memo, item|
-      begin
-        memo_mbchars = memo.unicode_normalize.grapheme_clusters
-        item_mbchars = item.unicode_normalize.grapheme_clusters
-      rescue Encoding::CompatibilityError
-        memo_mbchars = memo.grapheme_clusters
-        item_mbchars = item.grapheme_clusters
-      end
-      size = [memo_mbchars.size, item_mbchars.size].min
-      result = +''
-      size.times do |i|
-        if @config.completion_ignore_case
-          if memo_mbchars[i].casecmp?(item_mbchars[i])
-            result << memo_mbchars[i]
-          else
-            break
-          end
-        else
-          if memo_mbchars[i] == item_mbchars[i]
-            result << memo_mbchars[i]
-          else
-            break
-          end
-        end
-      end
-      result
-    }
-
-    [target, preposing, completed, postposing, candidates]
+    end.map do |item|
+      item.unicode_normalize
+    rescue Encoding::CompatibilityError
+      item
+    end.uniq
   end
 
-  private def perform_completion(list, just_show_list)
+  private def perform_completion(preposing, target, postposing, quote, list)
+    candidates = filter_normalize_candidates(target, list)
+
     case @completion_state
-    when CompletionState::NORMAL
-      @completion_state = CompletionState::COMPLETION
     when CompletionState::PERFECT_MATCH
       if @dig_perfect_match_proc
-        @dig_perfect_match_proc.(@perfect_matched)
-      else
-        @completion_state = CompletionState::COMPLETION
+        @dig_perfect_match_proc.call(@perfect_matched)
+        return
       end
-    end
-    if just_show_list
-      is_menu = true
-    elsif @completion_state == CompletionState::MENU
-      is_menu = true
-    elsif @completion_state == CompletionState::MENU_WITH_PERFECT_MATCH
-      is_menu = true
-    else
-      is_menu = false
-    end
-    result = complete_internal_proc(list, is_menu)
-    if @completion_state == CompletionState::MENU_WITH_PERFECT_MATCH
+    when CompletionState::MENU
+      menu(candidates)
+      return
+    when CompletionState::MENU_WITH_PERFECT_MATCH
+      menu(candidates)
       @completion_state = CompletionState::PERFECT_MATCH
+      return
     end
-    return if result.nil?
-    target, preposing, completed, postposing, candidates = result
-    return if completed.nil?
-    if target <= completed and (@completion_state == CompletionState::COMPLETION)
-      append_character = ''
-      if candidates.include?(completed)
-        if candidates.one?
-          append_character = completion_append_character.to_s
-          @completion_state = CompletionState::PERFECT_MATCH
-        else
-          @completion_state = CompletionState::MENU_WITH_PERFECT_MATCH
-          perform_completion(candidates, true) if @config.show_all_if_ambiguous
-        end
-        @perfect_matched = completed
+
+    completed = Reline::Unicode.common_prefix(candidates, ignore_case: @config.completion_ignore_case)
+    return if completed.empty?
+
+    append_character = ''
+    if candidates.include?(completed)
+      if candidates.one?
+        append_character = quote || completion_append_character.to_s
+        @completion_state = CompletionState::PERFECT_MATCH
+      elsif @config.show_all_if_ambiguous
+        menu(candidates)
+        @completion_state = CompletionState::PERFECT_MATCH
       else
-        @completion_state = CompletionState::MENU
-        perform_completion(candidates, true) if @config.show_all_if_ambiguous
-      end
-      unless just_show_list
-        @buffer_of_lines[@line_index] = (preposing + completed + append_character + postposing).split("\n")[@line_index] || String.new(encoding: encoding)
-        line_to_pointer = (preposing + completed + append_character).split("\n")[@line_index] || String.new(encoding: encoding)
-        @byte_pointer = line_to_pointer.bytesize
+        @completion_state = CompletionState::MENU_WITH_PERFECT_MATCH
       end
+      @perfect_matched = completed
+    else
+      @completion_state = CompletionState::MENU
+      menu(candidates) if @config.show_all_if_ambiguous
     end
+    @buffer_of_lines[@line_index] = (preposing + completed + append_character + postposing).split("\n")[@line_index] || String.new(encoding: encoding)
+    line_to_pointer = (preposing + completed + append_character).split("\n")[@line_index] || String.new(encoding: encoding)
+    @byte_pointer = line_to_pointer.bytesize
   end
 
   def dialog_proc_scope_completion_journey_data
@@ -927,8 +894,8 @@ class Reline::LineEditor
   end
 
   private def retrieve_completion_journey_state
-    preposing, target, postposing = retrieve_completion_block
-    list = call_completion_proc
+    preposing, target, postposing, quote = retrieve_completion_block
+    list = call_completion_proc(preposing, target, postposing, quote)
     return unless list.is_a?(Array)
 
     candidates = list.select{ |item| item.start_with?(target) }
@@ -1068,20 +1035,11 @@ class Reline::LineEditor
   end
 
   private def normal_char(key)
-    @multibyte_buffer << key.combined_char
-    if @multibyte_buffer.size > 1
-      if @multibyte_buffer.dup.force_encoding(encoding).valid_encoding?
-        process_key(@multibyte_buffer.dup.force_encoding(encoding), nil)
-        @multibyte_buffer.clear
-      else
-        # invalid
-        return
-      end
-    else # single byte
-      return if key.char >= 128 # maybe, first byte of multi byte
+    if key.char < 0x80
       method_symbol = @config.editing_mode.get_method(key.combined_char)
       process_key(key.combined_char, method_symbol)
-      @multibyte_buffer.clear
+    else
+      process_key(key.char.chr(encoding), nil)
     end
     if @config.editing_mode_is?(:vi_command) and @byte_pointer > 0 and @byte_pointer == current_line.bytesize
       byte_size = Reline::Unicode.get_prev_mbchar_size(@buffer_of_lines[@line_index], @byte_pointer)
@@ -1178,9 +1136,8 @@ class Reline::LineEditor
     end
   end
 
-  def call_completion_proc
-    result = retrieve_completion_block(true)
-    pre, target, post = result
+  def call_completion_proc(pre, target, post, quote)
+    Reline.core.instance_variable_set(:@completion_quote_character, quote)
     result = call_completion_proc_with_checking_args(pre, target, post)
     Reline.core.instance_variable_set(:@completion_quote_character, nil)
     result
@@ -1256,72 +1213,32 @@ class Reline::LineEditor
     process_auto_indent
   end
 
-  def retrieve_completion_block(set_completion_quote_character = false)
-    if Reline.completer_word_break_characters.empty?
-      word_break_regexp = nil
-    else
-      word_break_regexp = /\A[#{Regexp.escape(Reline.completer_word_break_characters)}]/
-    end
-    if Reline.completer_quote_characters.empty?
-      quote_characters_regexp = nil
-    else
-      quote_characters_regexp = /\A[#{Regexp.escape(Reline.completer_quote_characters)}]/
-    end
-    before = current_line.byteslice(0, @byte_pointer)
-    rest = nil
-    break_pointer = nil
+  def retrieve_completion_block
+    quote_characters = Reline.completer_quote_characters
+    before = current_line.byteslice(0, @byte_pointer).grapheme_clusters
     quote = nil
-    closing_quote = nil
-    escaped_quote = nil
-    i = 0
-    while i < @byte_pointer do
-      slice = current_line.byteslice(i, @byte_pointer - i)
-      unless slice.valid_encoding?
-        i += 1
-        next
-      end
-      if quote and slice.start_with?(closing_quote)
-        quote = nil
-        i += 1
-        rest = nil
-      elsif quote and slice.start_with?(escaped_quote)
-        # skip
-        i += 2
-      elsif quote_characters_regexp and slice =~ quote_characters_regexp # find new "
-        rest = $'
-        quote = $&
-        closing_quote = /(?!\\)#{Regexp.escape(quote)}/
-        escaped_quote = /\\#{Regexp.escape(quote)}/
-        i += 1
-        break_pointer = i - 1
-      elsif word_break_regexp and not quote and slice =~ word_break_regexp
-        rest = $'
-        i += 1
-        before = current_line.byteslice(i, @byte_pointer - i)
-        break_pointer = i
-      else
-        i += 1
-      end
-    end
-    postposing = current_line.byteslice(@byte_pointer, current_line.bytesize - @byte_pointer)
-    if rest
-      preposing = current_line.byteslice(0, break_pointer)
-      target = rest
-      if set_completion_quote_character and quote
-        Reline.core.instance_variable_set(:@completion_quote_character, quote)
-        if postposing !~ /(?!\\)#{Regexp.escape(quote)}/ # closing quote
-          insert_text(quote)
+    # Calcualte closing quote when cursor is at the end of the line
+    if current_line.bytesize == @byte_pointer && !quote_characters.empty?
+      escaped = false
+      before.each do |c|
+        if escaped
+          escaped = false
+          next
+        elsif c == '\\'
+          escaped = true
+        elsif quote
+          quote = nil if c == quote
+        elsif quote_characters.include?(c)
+          quote = c
         end
       end
-    else
-      preposing = ''
-      if break_pointer
-        preposing = current_line.byteslice(0, break_pointer)
-      else
-        preposing = ''
-      end
-      target = before
     end
+
+    word_break_characters = quote_characters + Reline.completer_word_break_characters
+    break_index = before.rindex { |c| word_break_characters.include?(c) || quote_characters.include?(c) } || -1
+    preposing = before.take(break_index + 1).join
+    target = before.drop(break_index + 1).join
+    postposing = current_line.byteslice(@byte_pointer, current_line.bytesize - @byte_pointer)
     lines = whole_lines
     if @line_index > 0
       preposing = lines[0..(@line_index - 1)].join("\n") + "\n" + preposing
@@ -1329,7 +1246,7 @@ class Reline::LineEditor
     if (lines.size - 1) > @line_index
       postposing = postposing + "\n" + lines[(@line_index + 1)..-1].join("\n")
     end
-    [preposing.encode(encoding), target.encode(encoding), postposing.encode(encoding)]
+    [preposing.encode(encoding), target.encode(encoding), postposing.encode(encoding), quote&.encode(encoding)]
   end
 
   def confirm_multiline_termination
@@ -1460,10 +1377,11 @@ class Reline::LineEditor
       @completion_occurs = move_completed_list(:down)
     else
       @completion_journey_state = nil
-      result = call_completion_proc
+      pre, target, post, quote = retrieve_completion_block
+      result = call_completion_proc(pre, target, post, quote)
       if result.is_a?(Array)
         @completion_occurs = true
-        perform_completion(result, false)
+        perform_completion(pre, target, post, quote, result)
       end
     end
   end
@@ -1582,7 +1500,7 @@ class Reline::LineEditor
   alias_method :backward_char, :ed_prev_char
 
   private def vi_first_print(key)
-    @byte_pointer, = Reline::Unicode.vi_first_print(current_line)
+    @byte_pointer = Reline::Unicode.vi_first_print(current_line)
   end
 
   private def ed_move_to_beg(key)
@@ -1598,7 +1516,6 @@ class Reline::LineEditor
 
   private def generate_searcher(search_key)
     search_word = String.new(encoding: encoding)
-    multibyte_buf = String.new(encoding: 'ASCII-8BIT')
     hit_pointer = nil
     lambda do |key|
       search_again = false
@@ -1613,11 +1530,7 @@ class Reline::LineEditor
         search_again = true if search_key == key
         search_key = key
       else
-        multibyte_buf << key
-        if multibyte_buf.dup.force_encoding(encoding).valid_encoding?
-          search_word << multibyte_buf.dup.force_encoding(encoding)
-          multibyte_buf.clear
-        end
+        search_word << key
       end
       hit = nil
       if not search_word.empty? and @line_backup_in_history&.include?(search_word)
@@ -1927,9 +1840,11 @@ class Reline::LineEditor
     if current_line.empty? or @byte_pointer < current_line.bytesize
       em_delete(key)
     elsif !@config.autocompletion # show completed list
-      result = call_completion_proc
+      pre, target, post, quote = retrieve_completion_block
+      result = call_completion_proc(pre, target, post, quote)
       if result.is_a?(Array)
-        perform_completion(result, true)
+        candidates = filter_normalize_candidates(target, result)
+        menu(candidates)
       end
     end
   end
@@ -1961,7 +1876,7 @@ class Reline::LineEditor
 
   private def em_next_word(key)
     if current_line.bytesize > @byte_pointer
-      byte_size, _ = Reline::Unicode.em_forward_word(current_line, @byte_pointer)
+      byte_size = Reline::Unicode.em_forward_word(current_line, @byte_pointer)
       @byte_pointer += byte_size
     end
   end
@@ -1969,7 +1884,7 @@ class Reline::LineEditor
 
   private def ed_prev_word(key)
     if @byte_pointer > 0
-      byte_size, _ = Reline::Unicode.em_backward_word(current_line, @byte_pointer)
+      byte_size = Reline::Unicode.em_backward_word(current_line, @byte_pointer)
       @byte_pointer -= byte_size
     end
   end
@@ -1977,7 +1892,7 @@ class Reline::LineEditor
 
   private def em_delete_next_word(key)
     if current_line.bytesize > @byte_pointer
-      byte_size, _ = Reline::Unicode.em_forward_word(current_line, @byte_pointer)
+      byte_size = Reline::Unicode.em_forward_word(current_line, @byte_pointer)
       line, word = byteslice!(current_line, @byte_pointer, byte_size)
       set_current_line(line)
       @kill_ring.append(word)
@@ -1987,7 +1902,7 @@ class Reline::LineEditor
 
   private def ed_delete_prev_word(key)
     if @byte_pointer > 0
-      byte_size, _ = Reline::Unicode.em_backward_word(current_line, @byte_pointer)
+      byte_size = Reline::Unicode.em_backward_word(current_line, @byte_pointer)
       line, word = byteslice!(current_line, @byte_pointer - byte_size, byte_size)
       set_current_line(line, @byte_pointer - byte_size)
       @kill_ring.append(word, true)
@@ -2027,7 +1942,7 @@ class Reline::LineEditor
 
   private def em_capitol_case(key)
     if current_line.bytesize > @byte_pointer
-      byte_size, _, new_str = Reline::Unicode.em_forward_word_with_capitalization(current_line, @byte_pointer)
+      byte_size, new_str = Reline::Unicode.em_forward_word_with_capitalization(current_line, @byte_pointer)
       before = current_line.byteslice(0, @byte_pointer)
       after = current_line.byteslice((@byte_pointer + byte_size)..-1)
       set_current_line(before + new_str + after, @byte_pointer + new_str.bytesize)
@@ -2037,7 +1952,7 @@ class Reline::LineEditor
 
   private def em_lower_case(key)
     if current_line.bytesize > @byte_pointer
-      byte_size, = Reline::Unicode.em_forward_word(current_line, @byte_pointer)
+      byte_size = Reline::Unicode.em_forward_word(current_line, @byte_pointer)
       part = current_line.byteslice(@byte_pointer, byte_size).grapheme_clusters.map { |mbchar|
         mbchar =~ /[A-Z]/ ? mbchar.downcase : mbchar
       }.join
@@ -2050,7 +1965,7 @@ class Reline::LineEditor
 
   private def em_upper_case(key)
     if current_line.bytesize > @byte_pointer
-      byte_size, = Reline::Unicode.em_forward_word(current_line, @byte_pointer)
+      byte_size = Reline::Unicode.em_forward_word(current_line, @byte_pointer)
       part = current_line.byteslice(@byte_pointer, byte_size).grapheme_clusters.map { |mbchar|
         mbchar =~ /[a-z]/ ? mbchar.upcase : mbchar
       }.join
@@ -2063,7 +1978,7 @@ class Reline::LineEditor
 
   private def em_kill_region(key)
     if @byte_pointer > 0
-      byte_size, _ = Reline::Unicode.em_big_backward_word(current_line, @byte_pointer)
+      byte_size = Reline::Unicode.em_big_backward_word(current_line, @byte_pointer)
       line, deleted = byteslice!(current_line, @byte_pointer - byte_size, byte_size)
       set_current_line(line, @byte_pointer - byte_size)
       @kill_ring.append(deleted, true)
@@ -2094,7 +2009,7 @@ class Reline::LineEditor
 
   private def vi_next_word(key, arg: 1)
     if current_line.bytesize > @byte_pointer
-      byte_size, _ = Reline::Unicode.vi_forward_word(current_line, @byte_pointer, @drop_terminate_spaces)
+      byte_size = Reline::Unicode.vi_forward_word(current_line, @byte_pointer, @drop_terminate_spaces)
       @byte_pointer += byte_size
     end
     arg -= 1
@@ -2103,7 +2018,7 @@ class Reline::LineEditor
 
   private def vi_prev_word(key, arg: 1)
     if @byte_pointer > 0
-      byte_size, _ = Reline::Unicode.vi_backward_word(current_line, @byte_pointer)
+      byte_size = Reline::Unicode.vi_backward_word(current_line, @byte_pointer)
       @byte_pointer -= byte_size
     end
     arg -= 1
@@ -2112,7 +2027,7 @@ class Reline::LineEditor
 
   private def vi_end_word(key, arg: 1, inclusive: false)
     if current_line.bytesize > @byte_pointer
-      byte_size, _ = Reline::Unicode.vi_forward_end_word(current_line, @byte_pointer)
+      byte_size = Reline::Unicode.vi_forward_end_word(current_line, @byte_pointer)
       @byte_pointer += byte_size
     end
     arg -= 1
@@ -2127,7 +2042,7 @@ class Reline::LineEditor
 
   private def vi_next_big_word(key, arg: 1)
     if current_line.bytesize > @byte_pointer
-      byte_size, _ = Reline::Unicode.vi_big_forward_word(current_line, @byte_pointer)
+      byte_size = Reline::Unicode.vi_big_forward_word(current_line, @byte_pointer)
       @byte_pointer += byte_size
     end
     arg -= 1
@@ -2136,7 +2051,7 @@ class Reline::LineEditor
 
   private def vi_prev_big_word(key, arg: 1)
     if @byte_pointer > 0
-      byte_size, _ = Reline::Unicode.vi_big_backward_word(current_line, @byte_pointer)
+      byte_size = Reline::Unicode.vi_big_backward_word(current_line, @byte_pointer)
       @byte_pointer -= byte_size
     end
     arg -= 1
@@ -2145,7 +2060,7 @@ class Reline::LineEditor
 
   private def vi_end_big_word(key, arg: 1, inclusive: false)
     if current_line.bytesize > @byte_pointer
-      byte_size, _ = Reline::Unicode.vi_big_forward_end_word(current_line, @byte_pointer)
+      byte_size = Reline::Unicode.vi_big_forward_end_word(current_line, @byte_pointer)
       @byte_pointer += byte_size
     end
     arg -= 1

data/lib/reline/unicode.rb

@@ -121,9 +121,14 @@ class Reline::Unicode
     end
   end
 
-  def self.split_by_width(str, max_width, encoding = str.encoding, offset: 0)
+  # This method is used by IRB
+  def self.split_by_width(str, max_width)
+    lines = split_line_by_width(str, max_width)
+    [lines, lines.size]
+  end
+
+  def self.split_line_by_width(str, max_width, encoding = str.encoding, offset: 0)
     lines = [String.new(encoding: encoding)]
-    height = 1
     width = offset
     rest = str.encode(Encoding::UTF_8)
     in_zero_width = false
@@ -151,9 +156,7 @@ class Reline::Unicode
           mbchar_width = get_mbchar_width(gc)
           if (width += mbchar_width) > max_width
             width = mbchar_width
-            lines << nil
             lines << seq.dup
-            height += 1
           end
         end
         lines.last << gc
@@ -161,11 +164,9 @@ class Reline::Unicode
     end
     # The cursor moves to next line in first
     if width == max_width
-      lines << nil
       lines << String.new(encoding: encoding)
-      height += 1
     end
-    [lines, height]
+    lines
   end
 
   def self.strip_non_printing_start_end(prompt)
@@ -261,27 +262,23 @@ class Reline::Unicode
   end
 
   def self.em_forward_word(line, byte_pointer)
-    width = 0
     byte_size = 0
     while line.bytesize > (byte_pointer + byte_size)
       size = get_next_mbchar_size(line, byte_pointer + byte_size)
       mbchar = line.byteslice(byte_pointer + byte_size, size)
       break if mbchar.encode(Encoding::UTF_8) =~ /\p{Word}/
-      width += get_mbchar_width(mbchar)
       byte_size += size
     end
     while line.bytesize > (byte_pointer + byte_size)
       size = get_next_mbchar_size(line, byte_pointer + byte_size)
       mbchar = line.byteslice(byte_pointer + byte_size, size)
       break if mbchar.encode(Encoding::UTF_8) =~ /\P{Word}/
-      width += get_mbchar_width(mbchar)
       byte_size += size
     end
-    [byte_size, width]
+    byte_size
   end
 
   def self.em_forward_word_with_capitalization(line, byte_pointer)
-    width = 0
     byte_size = 0
     new_str = String.new
     while line.bytesize > (byte_pointer + byte_size)
@@ -289,7 +286,6 @@ class Reline::Unicode
       mbchar = line.byteslice(byte_pointer + byte_size, size)
       break if mbchar.encode(Encoding::UTF_8) =~ /\p{Word}/
       new_str += mbchar
-      width += get_mbchar_width(mbchar)
       byte_size += size
     end
     first = true
@@ -303,50 +299,43 @@ class Reline::Unicode
       else
         new_str += mbchar.downcase
       end
-      width += get_mbchar_width(mbchar)
       byte_size += size
     end
-    [byte_size, width, new_str]
+    [byte_size, new_str]
   end
 
   def self.em_backward_word(line, byte_pointer)
-    width = 0
     byte_size = 0
     while 0 < (byte_pointer - byte_size)
       size = get_prev_mbchar_size(line, byte_pointer - byte_size)
       mbchar = line.byteslice(byte_pointer - byte_size - size, size)
       break if mbchar.encode(Encoding::UTF_8) =~ /\p{Word}/
-      width += get_mbchar_width(mbchar)
       byte_size += size
     end
     while 0 < (byte_pointer - byte_size)
       size = get_prev_mbchar_size(line, byte_pointer - byte_size)
       mbchar = line.byteslice(byte_pointer - byte_size - size, size)
       break if mbchar.encode(Encoding::UTF_8) =~ /\P{Word}/
-      width += get_mbchar_width(mbchar)
       byte_size += size
     end
-    [byte_size, width]
+    byte_size
   end
 
   def self.em_big_backward_word(line, byte_pointer)
-    width = 0
     byte_size = 0
     while 0 < (byte_pointer - byte_size)
       size = get_prev_mbchar_size(line, byte_pointer - byte_size)
       mbchar = line.byteslice(byte_pointer - byte_size - size, size)
       break if mbchar =~ /\S/
-      width += get_mbchar_width(mbchar)
       byte_size += size
     end
     while 0 < (byte_pointer - byte_size)
       size = get_prev_mbchar_size(line, byte_pointer - byte_size)
       mbchar = line.byteslice(byte_pointer - byte_size - size, size)
       break if mbchar =~ /\s/
-      width += get_mbchar_width(mbchar)
       byte_size += size
     end
-    [byte_size, width]
+    byte_size
   end
 
   def self.ed_transpose_words(line, byte_pointer)
@@ -451,73 +440,61 @@ class Reline::Unicode
   end
 
   def self.vi_big_forward_word(line, byte_pointer)
-    width = 0
     byte_size = 0
     while (line.bytesize - 1) > (byte_pointer + byte_size)
       size = get_next_mbchar_size(line, byte_pointer + byte_size)
       mbchar = line.byteslice(byte_pointer + byte_size, size)
       break if mbchar =~ /\s/
-      width += get_mbchar_width(mbchar)
       byte_size += size
     end
     while (line.bytesize - 1) > (byte_pointer + byte_size)
       size = get_next_mbchar_size(line, byte_pointer + byte_size)
       mbchar = line.byteslice(byte_pointer + byte_size, size)
       break if mbchar =~ /\S/
-      width += get_mbchar_width(mbchar)
       byte_size += size
     end
-    [byte_size, width]
+    byte_size
   end
 
   def self.vi_big_forward_end_word(line, byte_pointer)
     if (line.bytesize - 1) > byte_pointer
       size = get_next_mbchar_size(line, byte_pointer)
-      mbchar = line.byteslice(byte_pointer, size)
-      width = get_mbchar_width(mbchar)
       byte_size = size
     else
-      return [0, 0]
+      return 0
     end
     while (line.bytesize - 1) > (byte_pointer + byte_size)
       size = get_next_mbchar_size(line, byte_pointer + byte_size)
       mbchar = line.byteslice(byte_pointer + byte_size, size)
       break if mbchar =~ /\S/
-      width += get_mbchar_width(mbchar)
       byte_size += size
     end
-    prev_width = width
     prev_byte_size = byte_size
     while line.bytesize > (byte_pointer + byte_size)
       size = get_next_mbchar_size(line, byte_pointer + byte_size)
       mbchar = line.byteslice(byte_pointer + byte_size, size)
       break if mbchar =~ /\s/
-      prev_width = width
       prev_byte_size = byte_size
-      width += get_mbchar_width(mbchar)
       byte_size += size
     end
-    [prev_byte_size, prev_width]
+    prev_byte_size
   end
 
   def self.vi_big_backward_word(line, byte_pointer)
-    width = 0
     byte_size = 0
     while 0 < (byte_pointer - byte_size)
       size = get_prev_mbchar_size(line, byte_pointer - byte_size)
       mbchar = line.byteslice(byte_pointer - byte_size - size, size)
       break if mbchar =~ /\S/
-      width += get_mbchar_width(mbchar)
       byte_size += size
     end
     while 0 < (byte_pointer - byte_size)
       size = get_prev_mbchar_size(line, byte_pointer - byte_size)
       mbchar = line.byteslice(byte_pointer - byte_size - size, size)
       break if mbchar =~ /\s/
-      width += get_mbchar_width(mbchar)
       byte_size += size
     end
-    [byte_size, width]
+    byte_size
   end
 
   def self.vi_forward_word(line, byte_pointer, drop_terminate_spaces = false)
@@ -531,10 +508,9 @@ class Reline::Unicode
       else
         started_by = :non_word_printable
       end
-      width = get_mbchar_width(mbchar)
       byte_size = size
     else
-      return [0, 0]
+      return 0
     end
     while line.bytesize > (byte_pointer + byte_size)
       size = get_next_mbchar_size(line, byte_pointer + byte_size)
@@ -547,18 +523,16 @@ class Reline::Unicode
       when :non_word_printable
         break if mbchar =~ /\w|\s/
       end
-      width += get_mbchar_width(mbchar)
       byte_size += size
     end
-    return [byte_size, width] if drop_terminate_spaces
+    return byte_size if drop_terminate_spaces
     while line.bytesize > (byte_pointer + byte_size)
       size = get_next_mbchar_size(line, byte_pointer + byte_size)
       mbchar = line.byteslice(byte_pointer + byte_size, size)
       break if mbchar =~ /\S/
-      width += get_mbchar_width(mbchar)
       byte_size += size
     end
-    [byte_size, width]
+    byte_size
   end
 
   def self.vi_forward_end_word(line, byte_pointer)
@@ -572,10 +546,9 @@ class Reline::Unicode
       else
         started_by = :non_word_printable
       end
-      width = get_mbchar_width(mbchar)
       byte_size = size
     else
-      return [0, 0]
+      return 0
     end
     if (line.bytesize - 1) > (byte_pointer + byte_size)
       size = get_next_mbchar_size(line, byte_pointer + byte_size)
@@ -587,13 +560,11 @@ class Reline::Unicode
       else
         second = :non_word_printable
       end
-      second_width = get_mbchar_width(mbchar)
       second_byte_size = size
     else
-      return [byte_size, width]
+      return byte_size
     end
     if second == :space
-      width += second_width
       byte_size += second_byte_size
       while (line.bytesize - 1) > (byte_pointer + byte_size)
         size = get_next_mbchar_size(line, byte_pointer + byte_size)
@@ -606,7 +577,6 @@ class Reline::Unicode
           end
           break
         end
-        width += get_mbchar_width(mbchar)
         byte_size += size
       end
     else
@@ -614,12 +584,10 @@ class Reline::Unicode
       when [:word, :non_word_printable], [:non_word_printable, :word]
         started_by = second
       else
-        width += second_width
         byte_size += second_byte_size
         started_by = second
       end
     end
-    prev_width = width
     prev_byte_size = byte_size
     while line.bytesize > (byte_pointer + byte_size)
       size = get_next_mbchar_size(line, byte_pointer + byte_size)
@@ -630,16 +598,13 @@ class Reline::Unicode
       when :non_word_printable
         break if mbchar =~ /[\w\s]/
       end
-      prev_width = width
       prev_byte_size = byte_size
-      width += get_mbchar_width(mbchar)
       byte_size += size
     end
-    [prev_byte_size, prev_width]
+    prev_byte_size
   end
 
   def self.vi_backward_word(line, byte_pointer)
-    width = 0
     byte_size = 0
     while 0 < (byte_pointer - byte_size)
       size = get_prev_mbchar_size(line, byte_pointer - byte_size)
@@ -652,7 +617,6 @@ class Reline::Unicode
         end
         break
       end
-      width += get_mbchar_width(mbchar)
       byte_size += size
     end
     while 0 < (byte_pointer - byte_size)
@@ -664,14 +628,25 @@ class Reline::Unicode
       when :non_word_printable
         break if mbchar =~ /[\w\s]/
       end
-      width += get_mbchar_width(mbchar)
       byte_size += size
     end
-    [byte_size, width]
+    byte_size
+  end
+
+  def self.common_prefix(list, ignore_case: false)
+    return '' if list.empty?
+
+    common_prefix_gcs = list.first.grapheme_clusters
+    list.each do |item|
+      gcs = item.grapheme_clusters
+      common_prefix_gcs = common_prefix_gcs.take_while.with_index do |gc, i|
+        ignore_case ? gc.casecmp?(gcs[i]) : gc == gcs[i]
+      end
+    end
+    common_prefix_gcs.join
   end
 
   def self.vi_first_print(line)
-    width = 0
     byte_size = 0
     while (line.bytesize - 1) > byte_size
       size = get_next_mbchar_size(line, byte_size)
@@ -679,9 +654,8 @@ class Reline::Unicode
       if mbchar =~ /\S/
         break
       end
-      width += get_mbchar_width(mbchar)
       byte_size += size
     end
-    [byte_size, width]
+    byte_size
   end
 end

data/lib/reline/version.rb

@@ -1,3 +1,3 @@
 module Reline
-  VERSION = '0.5.11'
+  VERSION = '0.5.12'
 end

data/lib/reline.rb

@@ -6,7 +6,6 @@ require 'reline/key_actor'
 require 'reline/key_stroke'
 require 'reline/line_editor'
 require 'reline/history'
-require 'reline/terminfo'
 require 'reline/io'
 require 'reline/face'
 require 'rbconfig'
@@ -308,6 +307,7 @@ module Reline
       otio = io_gate.prep
 
       may_req_ambiguous_char_width
+      key_stroke.encoding = encoding
       line_editor.reset(prompt)
       if multiline
         line_editor.multiline_on
@@ -486,7 +486,7 @@ module Reline
   def self.core
     @core ||= Core.new { |core|
       core.config = Reline::Config.new
-      core.key_stroke = Reline::KeyStroke.new(core.config)
+      core.key_stroke = Reline::KeyStroke.new(core.config, core.encoding)
       core.line_editor = Reline::LineEditor.new(core.config)
 
       core.basic_word_break_characters = " \t\n`><=;|&{("

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: reline
 version: !ruby/object:Gem::Version
-  version: 0.5.11
+  version: 0.5.12
 platform: ruby
+original_platform: ''
 authors:
 - aycabta
 bindir: bin
 cert_chain: []
-date: 2024-11-08 00:00:00.000000000 Z
+date: 2024-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: io-console
@@ -50,7 +51,6 @@ files:
 - lib/reline/key_stroke.rb
 - lib/reline/kill_ring.rb
 - lib/reline/line_editor.rb
-- lib/reline/terminfo.rb
 - lib/reline/unicode.rb
 - lib/reline/unicode/east_asian_width.rb
 - lib/reline/version.rb

data/lib/reline/terminfo.rb

@@ -1,158 +0,0 @@
-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
-  module Reline::Terminfo
-    def self.curses_dl
-      false
-    end
-  end
-ensure
-  $VERBOSE = verbose
-end
-
-module Reline::Terminfo
-  extend Fiddle::Importer
-
-  class TerminfoError < StandardError; end
-
-  def self.curses_dl_files
-    case RUBY_PLATFORM
-    when /mingw/, /mswin/
-      # aren't supported
-      []
-    when /cygwin/
-      %w[cygncursesw-10.dll cygncurses-10.dll]
-    when /darwin/
-      %w[libncursesw.dylib libcursesw.dylib libncurses.dylib libcurses.dylib]
-    else
-      %w[libncursesw.so libcursesw.so libncurses.so libcurses.so]
-    end
-  end
-
-  @curses_dl = false
-  def self.curses_dl
-    return @curses_dl unless @curses_dl == false
-    if Fiddle.const_defined?(:TYPE_VARIADIC)
-      curses_dl_files.each do |curses_name|
-        result = Fiddle::Handle.new(curses_name)
-      rescue Fiddle::DLError
-        next
-      else
-        @curses_dl = result
-        break
-      end
-    end
-    @curses_dl = nil if @curses_dl == false
-    @curses_dl
-  end
-end if not Reline.const_defined?(:Terminfo) or not Reline::Terminfo.respond_to?(:curses_dl)
-
-module Reline::Terminfo
-  dlload curses_dl
-  #extern 'int setupterm(char *term, int fildes, int *errret)'
-  @setupterm = Fiddle::Function.new(curses_dl['setupterm'], [Fiddle::TYPE_VOIDP, Fiddle::TYPE_INT, Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT)
-  #extern 'char *tigetstr(char *capname)'
-  @tigetstr = Fiddle::Function.new(curses_dl['tigetstr'], [Fiddle::TYPE_VOIDP], Fiddle::TYPE_VOIDP)
-  begin
-    #extern 'char *tiparm(const char *str, ...)'
-    @tiparm = Fiddle::Function.new(curses_dl['tiparm'], [Fiddle::TYPE_VOIDP, Fiddle::TYPE_VARIADIC], Fiddle::TYPE_VOIDP)
-  rescue Fiddle::DLError
-    # OpenBSD lacks tiparm
-    #extern 'char *tparm(const char *str, ...)'
-    @tiparm = Fiddle::Function.new(curses_dl['tparm'], [Fiddle::TYPE_VOIDP, Fiddle::TYPE_VARIADIC], Fiddle::TYPE_VOIDP)
-  end
-  begin
-    #extern 'int tigetflag(char *str)'
-    @tigetflag = Fiddle::Function.new(curses_dl['tigetflag'], [Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT)
-  rescue Fiddle::DLError
-    # OpenBSD lacks tigetflag
-    #extern 'int tgetflag(char *str)'
-    @tigetflag = Fiddle::Function.new(curses_dl['tgetflag'], [Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT)
-  end
-  begin
-    #extern 'int tigetnum(char *str)'
-    @tigetnum = Fiddle::Function.new(curses_dl['tigetnum'], [Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT)
-  rescue Fiddle::DLError
-    # OpenBSD lacks tigetnum
-    #extern 'int tgetnum(char *str)'
-    @tigetnum = Fiddle::Function.new(curses_dl['tgetnum'], [Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT)
-  end
-
-  def self.setupterm(term, fildes)
-    errret_int = Fiddle::Pointer.malloc(Fiddle::SIZEOF_INT, Fiddle::RUBY_FREE)
-    ret = @setupterm.(term, fildes, errret_int)
-    case ret
-    when 0 # OK
-      @term_supported = true
-    when -1 # ERR
-      @term_supported = false
-    end
-  end
-
-  class StringWithTiparm < String
-    def tiparm(*args) # for method chain
-      Reline::Terminfo.tiparm(self, *args)
-    end
-  end
-
-  def self.tigetstr(capname)
-    raise TerminfoError, "capname is not String: #{capname.inspect}" unless capname.is_a?(String)
-    capability = @tigetstr.(capname)
-    case capability.to_i
-    when 0, -1
-      raise TerminfoError, "can't find capability: #{capname}"
-    end
-    StringWithTiparm.new(capability.to_s)
-  end
-
-  def self.tiparm(str, *args)
-    new_args = []
-    args.each do |a|
-      new_args << Fiddle::TYPE_INT << a
-    end
-    @tiparm.(str, *new_args).to_s
-  end
-
-  def self.tigetflag(capname)
-    raise TerminfoError, "capname is not String: #{capname.inspect}" unless capname.is_a?(String)
-    flag = @tigetflag.(capname).to_i
-    case flag
-    when -1
-      raise TerminfoError, "not boolean capability: #{capname}"
-    when 0
-      raise TerminfoError, "can't find capability: #{capname}"
-    end
-    flag
-  end
-
-  def self.tigetnum(capname)
-    raise TerminfoError, "capname is not String: #{capname.inspect}" unless capname.is_a?(String)
-    num = @tigetnum.(capname).to_i
-    case num
-    when -2
-      raise TerminfoError, "not numeric capability: #{capname}"
-    when -1
-      raise TerminfoError, "can't find capability: #{capname}"
-    end
-    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
-  def self.enabled?
-    false
-  end
-end unless Reline::Terminfo.curses_dl