reline 0.3.9 → 0.6.1

data/lib/reline/version.rb

@@ -1,3 +1,3 @@
 module Reline
-  VERSION = '0.3.9'
+  VERSION = '0.6.1'
 end

data/lib/reline.rb

@@ -6,45 +6,36 @@ 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'
 
 module Reline
   # NOTE: For making compatible with the rb-readline gem
-  FILENAME_COMPLETION_PROC = nil
-  USERNAME_COMPLETION_PROC = nil
-
-  class ConfigEncodingConversionError < StandardError; end
-
-  Key = Struct.new(:char, :combined_char, :with_meta) do
-    def match?(other)
-      case other
-      when Reline::Key
-        (other.char.nil? or char.nil? or char == other.char) and
-        (other.combined_char.nil? or combined_char.nil? or combined_char == other.combined_char) and
-        (other.with_meta.nil? or with_meta.nil? or with_meta == other.with_meta)
-      when Integer, Symbol
-        (combined_char and combined_char == other) or
-        (combined_char.nil? and char and char == other)
-      else
-        false
-      end
+  FILENAME_COMPLETION_PROC = nil # :nodoc:
+  USERNAME_COMPLETION_PROC = nil # :nodoc:
+
+  class ConfigEncodingConversionError < StandardError; end # :nodoc:
+
+  # EOF key: { char: nil, method_symbol: nil }
+  # Other key: { char: String, method_symbol: Symbol }
+  Key = Struct.new(:char, :method_symbol, :unused_boolean) do
+    # For dialog_proc `key.match?(dialog.name)`
+    def match?(sym)
+      method_symbol && method_symbol == sym
     end
-    alias_method :==, :match?
-  end
-  CursorPos = Struct.new(:x, :y)
+  end # :nodoc:
+  CursorPos = Struct.new(:x, :y) # :nodoc:
   DialogRenderInfo = Struct.new(
     :pos,
     :contents,
-    :bg_color,
-    :pointer_bg_color,
-    :fg_color,
-    :pointer_fg_color,
+    :face,
+    :bg_color, # For the time being, this line should stay here for the compatibility with IRB.
     :width,
     :height,
     :scrollbar,
     keyword_init: true
-  )
+  ) # :nodoc:
 
   class Core
     ATTR_READER_NAMES = %i(
@@ -76,10 +67,10 @@ module Reline
 
     def initialize
       self.output = STDOUT
+      @mutex = Mutex.new
       @dialog_proc_list = {}
       yield self
       @completion_quote_character = nil
-      @bracketed_paste_finished = false
     end
 
     def io_gate
@@ -192,9 +183,7 @@ module Reline
     def output=(val)
       raise TypeError unless val.respond_to?(:write) or val.nil?
       @output = val
-      if io_gate.respond_to?(:output=)
-        io_gate.output = val
-      end
+      io_gate.output = val
     end
 
     def vi_editing_mode
@@ -221,32 +210,25 @@ module Reline
 
     Reline::DEFAULT_DIALOG_PROC_AUTOCOMPLETE = ->() {
       # autocomplete
-      return nil unless config.autocompletion
-      if just_cursor_moving and completion_journey_data.nil?
-        # Auto complete starts only when edited
-        return nil
-      end
-      pre, target, post = retrieve_completion_block(true)
-      if target.nil? or target.empty? or (completion_journey_data&.pointer == -1 and target.size <= 3)
-        return nil
-      end
-      if completion_journey_data and completion_journey_data.list
-        result = completion_journey_data.list.dup
-        result.shift
-        pointer = completion_journey_data.pointer - 1
-      else
-        result = call_completion_proc_with_checking_args(pre, target, post)
-        pointer = nil
-      end
-      if result and result.size == 1 and result[0] == target and pointer != 0
-        result = nil
-      end
+      return unless config.autocompletion
+
+      journey_data = completion_journey_data
+      return unless journey_data
+
+      target = journey_data.list.first
+      completed = journey_data.list[journey_data.pointer]
+      result = journey_data.list.drop(1)
+      pointer = journey_data.pointer - 1
+      return if completed.empty? || (result == [completed] && pointer < 0)
+
       target_width = Reline::Unicode.calculate_width(target)
-      x = cursor_pos.x - target_width
-      if x < 0
-        x = screen_width + x
+      completed_width = Reline::Unicode.calculate_width(completed)
+      if cursor_pos.x <= completed_width - target_width
+        # When target is rendered on the line above cursor position
+        x = screen_width - completed_width
         y = -1
       else
+        x = [cursor_pos.x - completed_width, 0].max
         y = 0
       end
       cursor_pos_to_render = Reline::CursorPos.new(x, y)
@@ -260,21 +242,20 @@ module Reline
         contents: result,
         scrollbar: true,
         height: [15, preferred_dialog_height].min,
-        bg_color: 46,
-        pointer_bg_color: 45,
-        fg_color: 37,
-        pointer_fg_color: 37
+        face: :completion_dialog
       )
-    }
-    Reline::DEFAULT_DIALOG_CONTEXT = Array.new
+    } # :nodoc:
+    Reline::DEFAULT_DIALOG_CONTEXT = Array.new # :nodoc:
 
     def readmultiline(prompt = '', add_hist = false, &confirm_multiline_termination)
-      Reline.update_iogate
-      io_gate.with_raw_input do
+      @mutex.synchronize do
         unless confirm_multiline_termination
           raise ArgumentError.new('#readmultiline needs block to confirm multiline termination')
         end
-        inner_readline(prompt, add_hist, true, &confirm_multiline_termination)
+
+        io_gate.with_raw_input do
+          inner_readline(prompt, add_hist, true, &confirm_multiline_termination)
+        end
 
         whole_buffer = line_editor.whole_buffer.dup
         whole_buffer.taint if RUBY_VERSION < '2.7'
@@ -282,23 +263,31 @@ module Reline
           Reline::HISTORY << whole_buffer
         end
 
-        line_editor.reset_line if line_editor.whole_buffer.nil?
-        whole_buffer
+        if line_editor.eof?
+          line_editor.reset_line
+          # Return nil if the input is aborted by C-d.
+          nil
+        else
+          whole_buffer
+        end
       end
     end
 
     def readline(prompt = '', add_hist = false)
-      Reline.update_iogate
-      inner_readline(prompt, add_hist, false)
+      @mutex.synchronize do
+        io_gate.with_raw_input do
+          inner_readline(prompt, add_hist, false)
+        end
 
-      line = line_editor.line.dup
-      line.taint if RUBY_VERSION < '2.7'
-      if add_hist and line and line.chomp("\n").size > 0
-        Reline::HISTORY << line.chomp("\n")
-      end
+        line = line_editor.line.dup
+        line.taint if RUBY_VERSION < '2.7'
+        if add_hist and line and line.chomp("\n").size > 0
+          Reline::HISTORY << line.chomp("\n")
+        end
 
-      line_editor.reset_line if line_editor.line.nil?
-      line
+        line_editor.reset_line if line_editor.line.nil?
+        line
+      end
     end
 
     private def inner_readline(prompt, add_hist, multiline, &confirm_multiline_termination)
@@ -311,10 +300,15 @@ module Reline
         $stderr.sync = true
         $stderr.puts "Reline is used by #{Process.pid}"
       end
+      unless config.test_mode or config.loaded?
+        config.read
+        io_gate.set_default_key_bindings(config)
+      end
       otio = io_gate.prep
 
       may_req_ambiguous_char_width
-      line_editor.reset(prompt, encoding: encoding)
+      key_stroke.encoding = encoding
+      line_editor.reset(prompt)
       if multiline
         line_editor.multiline_on
         if block_given?
@@ -323,154 +317,91 @@ module Reline
       else
         line_editor.multiline_off
       end
-      line_editor.output = output
       line_editor.completion_proc = completion_proc
       line_editor.completion_append_character = completion_append_character
       line_editor.output_modifier_proc = output_modifier_proc
       line_editor.prompt_proc = prompt_proc
       line_editor.auto_indent_proc = auto_indent_proc
       line_editor.dig_perfect_match_proc = dig_perfect_match_proc
-      line_editor.pre_input_hook = pre_input_hook
-      @dialog_proc_list.each_pair do |name_sym, d|
-        line_editor.add_dialog_proc(name_sym, d.dialog_proc, d.context)
-      end
 
-      unless config.test_mode
-        config.read
-        config.reset_default_key_bindings
-        io_gate.set_default_key_bindings(config)
+      # Readline calls pre_input_hook just after printing the first prompt.
+      line_editor.print_nomultiline_prompt
+      pre_input_hook&.call
+
+      unless Reline::IOGate.dumb?
+        @dialog_proc_list.each_pair do |name_sym, d|
+          line_editor.add_dialog_proc(name_sym, d.dialog_proc, d.context)
+        end
       end
 
+      line_editor.update_dialogs
       line_editor.rerender
 
       begin
         line_editor.set_signal_handlers
-        prev_pasting_state = false
         loop do
-          prev_pasting_state = io_gate.in_pasting?
           read_io(config.keyseq_timeout) { |inputs|
-            line_editor.set_pasting_state(io_gate.in_pasting?)
-            inputs.each { |c|
-              line_editor.input_key(c)
-              line_editor.rerender
-            }
-            if @bracketed_paste_finished
-              line_editor.rerender_all
-              @bracketed_paste_finished = false
+            inputs.each do |key|
+              case key.method_symbol
+              when :bracketed_paste_start
+                # io_gate is Reline::ANSI because the key :bracketed_paste_start is only assigned in Reline::ANSI
+                key = Reline::Key.new(io_gate.read_bracketed_paste, :insert_multiline_text)
+              when :quoted_insert, :ed_quoted_insert
+                key = Reline::Key.new(io_gate.read_single_char(config.keyseq_timeout), :insert_raw_char)
+              end
+              line_editor.set_pasting_state(io_gate.in_pasting?)
+              line_editor.update(key)
             end
           }
-          if prev_pasting_state == true and not io_gate.in_pasting? and not line_editor.finished?
-            line_editor.set_pasting_state(false)
-            prev_pasting_state = false
-            line_editor.rerender_all
+          if line_editor.finished?
+            line_editor.render_finished
+            break
+          else
+            line_editor.rerender
           end
-          break if line_editor.finished?
         end
         io_gate.move_cursor_column(0)
       rescue Errno::EIO
         # Maybe the I/O has been closed.
-      rescue StandardError => e
-        line_editor.finalize
-        io_gate.deprep(otio)
-        raise e
-      rescue Exception
-        # Including Interrupt
+      ensure
         line_editor.finalize
         io_gate.deprep(otio)
-        raise
       end
-
-      line_editor.finalize
-      io_gate.deprep(otio)
     end
 
-    # GNU Readline waits for "keyseq-timeout" milliseconds to see if the ESC
-    # is followed by a character, and times out and treats it as a standalone
-    # ESC if the second character does not arrive. If the second character
-    # comes before timed out, it is treated as a modifier key with the
-    # meta-property of meta-key, so that it can be distinguished from
-    # multibyte characters with the 8th bit turned on.
-    #
-    # GNU Readline will wait for the 2nd character with "keyseq-timeout"
-    # milli-seconds but wait forever after 3rd characters.
+    # GNU Readline watis for "keyseq-timeout" milliseconds when the input is
+    # ambiguous whether it is matching or matched.
+    # If the next character does not arrive within the specified timeout, input
+    # is considered as matched.
+    # `ESC` is ambiguous because it can be a standalone ESC (matched) or part of
+    # `ESC char` or part of CSI sequence (matching).
     private def read_io(keyseq_timeout, &block)
       buffer = []
+      status = KeyStroke::MATCHING
       loop do
-        c = io_gate.getc(Float::INFINITY)
-        if c == -1
-          result = :unmatched
-          @bracketed_paste_finished = true
-        else
-          buffer << c
-          result = key_stroke.match_status(buffer)
-        end
-        case result
-        when :matched
-          expanded = key_stroke.expand(buffer).map{ |expanded_c|
-            Reline::Key.new(expanded_c, expanded_c, false)
-          }
-          block.(expanded)
-          break
-        when :matching
-          if buffer.size == 1
-            case read_2nd_character_of_key_sequence(keyseq_timeout, buffer, c, block)
-            when :break then break
-            when :next  then next
-            end
-          end
-        when :unmatched
-          if buffer.size == 1 and c == "\e".ord
-            read_escaped_key(keyseq_timeout, c, block)
+        timeout = status == KeyStroke::MATCHING_MATCHED ? keyseq_timeout.fdiv(1000) : Float::INFINITY
+        c = io_gate.getc(timeout)
+        if c.nil? || c == -1
+          if status == KeyStroke::MATCHING_MATCHED
+            status = KeyStroke::MATCHED
+          elsif buffer.empty?
+            # io_gate is closed and reached EOF
+            block.call([Key.new(nil, nil, false)])
+            return
           else
-            expanded = buffer.map{ |expanded_c|
-              Reline::Key.new(expanded_c, expanded_c, false)
-            }
-            block.(expanded)
+            status = KeyStroke::UNMATCHED
           end
-          break
+        else
+          buffer << c
+          status = key_stroke.match_status(buffer)
         end
-      end
-    end
 
-    private def read_2nd_character_of_key_sequence(keyseq_timeout, buffer, c, block)
-      succ_c = io_gate.getc(keyseq_timeout.fdiv(1000))
-      if succ_c
-        case key_stroke.match_status(buffer.dup.push(succ_c))
-        when :unmatched
-          if c == "\e".ord
-            block.([Reline::Key.new(succ_c, succ_c | 0b10000000, true)])
-          else
-            block.([Reline::Key.new(c, c, false), Reline::Key.new(succ_c, succ_c, false)])
-          end
-          return :break
-        when :matching
-          io_gate.ungetc(succ_c)
-          return :next
-        when :matched
-          buffer << succ_c
-          expanded = key_stroke.expand(buffer).map{ |expanded_c|
-            Reline::Key.new(expanded_c, expanded_c, false)
-          }
-          block.(expanded)
-          return :break
+        if status == KeyStroke::MATCHED || status == KeyStroke::UNMATCHED
+          expanded, rest_bytes = key_stroke.expand(buffer)
+          rest_bytes.reverse_each { |c| io_gate.ungetc(c) }
+          block.call(expanded)
+          return
         end
-      else
-        block.([Reline::Key.new(c, c, false)])
-        return :break
-      end
-    end
-
-    private def read_escaped_key(keyseq_timeout, c, block)
-      escaped_c = io_gate.getc(keyseq_timeout.fdiv(1000))
-
-      if escaped_c.nil?
-        block.([Reline::Key.new(c, c, false)])
-      elsif escaped_c >= 128 # maybe, first byte of multi byte
-        block.([Reline::Key.new(c, c, false), Reline::Key.new(escaped_c, escaped_c, false)])
-      elsif escaped_c == "\e".ord # escape twice
-        block.([Reline::Key.new(c, c, false), Reline::Key.new(c, c, false)])
-      else
-        block.([Reline::Key.new(escaped_c, escaped_c | 0b10000000, true)])
       end
     end
 
@@ -480,7 +411,7 @@ module Reline
     end
 
     private def may_req_ambiguous_char_width
-      @ambiguous_width = 2 if io_gate == Reline::GeneralIO or !STDOUT.tty?
+      @ambiguous_width = 1 if io_gate.dumb? || !STDIN.tty? || !STDOUT.tty?
       return if defined? @ambiguous_width
       io_gate.move_cursor_column(0)
       begin
@@ -489,7 +420,7 @@ module Reline
         # LANG=C
         @ambiguous_width = 1
       else
-        @ambiguous_width = io_gate.cursor_pos.x
+        @ambiguous_width = io_gate.cursor_pos.x == 2 ? 2 : 1
       end
       io_gate.move_cursor_column(0)
       io_gate.erase_after_cursor
@@ -508,6 +439,17 @@ module Reline
   }
   def_single_delegators :core, :input=, :output=
   def_single_delegators :core, :vi_editing_mode, :emacs_editing_mode
+
+  ##
+  # :singleton-method: readmultiline
+  # :call-seq:
+  #   readmultiline(prompt = '', add_hist = false, &confirm_multiline_termination) -> string or nil
+  def_single_delegators :core, :readmultiline
+
+  ##
+  # :singleton-method: readline
+  # :call-seq:
+  #   readline(prompt = '', add_hist = false) -> string or nil
   def_single_delegators :core, :readline
   def_single_delegators :core, :completion_case_fold, :completion_case_fold=
   def_single_delegators :core, :completion_quote_character
@@ -528,8 +470,8 @@ module Reline
   def_single_delegator :line_editor, :byte_pointer, :point
   def_single_delegator :line_editor, :byte_pointer=, :point=
 
-  def self.insert_text(*args, &block)
-    line_editor.insert_text(*args, &block)
+  def self.insert_text(text)
+    line_editor.insert_multiline_text(text)
     self
   end
 
@@ -543,19 +485,18 @@ module Reline
   def_single_delegators :core, :dialog_proc
   def_single_delegators :core, :autocompletion, :autocompletion=
 
-  def_single_delegators :core, :readmultiline
   def_instance_delegators self, :readmultiline
   private :readmultiline
 
-  def self.encoding_system_needs
+  def self.encoding_system_needs # :nodoc:
     self.core.encoding
   end
 
   def self.core
     @core ||= Core.new { |core|
       core.config = Reline::Config.new
-      core.key_stroke = Reline::KeyStroke.new(core.config)
-      core.line_editor = Reline::LineEditor.new(core.config, core.encoding)
+      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`><=;|&{("
       core.completer_word_break_characters = " \t\n`><=;|&{("
@@ -574,36 +515,14 @@ module Reline
   def self.line_editor
     core.line_editor
   end
+end
 
-  def self.update_iogate
-    return if core.config.test_mode
 
-    # Need to change IOGate when `$stdout.tty?` change from false to true by `$stdout.reopen`
-    # Example: rails/spring boot the application in non-tty, then run console in tty.
-    if ENV['TERM'] != 'dumb' && core.io_gate == Reline::GeneralIO && $stdout.tty?
-      require 'reline/ansi'
-      remove_const(:IOGate)
-      const_set(:IOGate, Reline::ANSI)
-    end
-  end
-end
+Reline::IOGate = Reline::IO.decide_io_gate
 
-require 'reline/general_io'
-io = Reline::GeneralIO
-unless ENV['TERM'] == 'dumb'
-  case RbConfig::CONFIG['host_os']
-  when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
-    require 'reline/windows'
-    tty = (io = Reline::Windows).msys_tty?
-  else
-    tty = $stdout.tty?
-  end
-end
-Reline::IOGate = if tty
-  require 'reline/ansi'
-  Reline::ANSI
-else
-  io
-end
+# Deprecated
+Reline::GeneralIO = Reline::Dumb.new # :nodoc:
+
+Reline::Face.load_initial_configs
 
 Reline::HISTORY = Reline::History.new(Reline.core.config)

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: reline
 version: !ruby/object:Gem::Version
-  version: 0.3.9
+  version: 0.6.1
 platform: ruby
 authors:
 - aycabta
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-10-03 00:00:00.000000000 Z
+date: 2025-04-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: io-console
@@ -35,29 +34,33 @@ files:
 - COPYING
 - README.md
 - lib/reline.rb
-- lib/reline/ansi.rb
 - lib/reline/config.rb
-- lib/reline/general_io.rb
+- lib/reline/face.rb
 - lib/reline/history.rb
+- lib/reline/io.rb
+- lib/reline/io/ansi.rb
+- lib/reline/io/dumb.rb
+- lib/reline/io/windows.rb
 - lib/reline/key_actor.rb
 - lib/reline/key_actor/base.rb
+- lib/reline/key_actor/composite.rb
 - lib/reline/key_actor/emacs.rb
 - lib/reline/key_actor/vi_command.rb
 - lib/reline/key_actor/vi_insert.rb
 - 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
-- lib/reline/windows.rb
 - license_of_rb-readline
 homepage: https://github.com/ruby/reline
 licenses:
 - Ruby
-metadata: {}
-post_install_message:
+metadata:
+  bug_tracker_uri: https://github.com/ruby/reline/issues
+  changelog_uri: https://github.com/ruby/reline/releases
+  source_code_uri: https://github.com/ruby/reline
 rdoc_options: []
 require_paths:
 - lib
@@ -72,8 +75,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.13
-signing_key:
+rubygems_version: 3.6.3
 specification_version: 4
 summary: Alternative GNU Readline or Editline implementation by pure Ruby.
 test_files: []