reline 0.3.5 → 0.6.2

data/lib/reline/version.rb

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

data/lib/reline.rb

@@ -1,5 +1,4 @@
 require 'io/console'
-require 'timeout'
 require 'forwardable'
 require 'reline/version'
 require 'reline/config'
@@ -7,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('Key', :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(
@@ -77,50 +67,54 @@ 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
+      Reline::IOGate
     end
 
     def encoding
-      Reline::IOGate.encoding
+      io_gate.encoding
     end
 
     def completion_append_character=(val)
       if val.nil?
         @completion_append_character = nil
       elsif val.size == 1
-        @completion_append_character = val.encode(Reline::IOGate.encoding)
+        @completion_append_character = val.encode(encoding)
       elsif val.size > 1
-        @completion_append_character = val[0].encode(Reline::IOGate.encoding)
+        @completion_append_character = val[0].encode(encoding)
       else
         @completion_append_character = nil
       end
     end
 
     def basic_word_break_characters=(v)
-      @basic_word_break_characters = v.encode(Reline::IOGate.encoding)
+      @basic_word_break_characters = v.encode(encoding)
     end
 
     def completer_word_break_characters=(v)
-      @completer_word_break_characters = v.encode(Reline::IOGate.encoding)
+      @completer_word_break_characters = v.encode(encoding)
     end
 
     def basic_quote_characters=(v)
-      @basic_quote_characters = v.encode(Reline::IOGate.encoding)
+      @basic_quote_characters = v.encode(encoding)
     end
 
     def completer_quote_characters=(v)
-      @completer_quote_characters = v.encode(Reline::IOGate.encoding)
+      @completer_quote_characters = v.encode(encoding)
     end
 
     def filename_quote_characters=(v)
-      @filename_quote_characters = v.encode(Reline::IOGate.encoding)
+      @filename_quote_characters = v.encode(encoding)
     end
 
     def special_prefixes=(v)
-      @special_prefixes = v.encode(Reline::IOGate.encoding)
+      @special_prefixes = v.encode(encoding)
     end
 
     def completion_case_fold=(v)
@@ -181,21 +175,15 @@ module Reline
 
     def input=(val)
       raise TypeError unless val.respond_to?(:getc) or val.nil?
-      if val.respond_to?(:getc)
-        if defined?(Reline::ANSI) and Reline::IOGate == Reline::ANSI
-          Reline::ANSI.input = val
-        elsif Reline::IOGate == Reline::GeneralIO
-          Reline::GeneralIO.input = val
-        end
+      if val.respond_to?(:getc) && io_gate.respond_to?(:input=)
+        io_gate.input = val
       end
     end
 
     def output=(val)
       raise TypeError unless val.respond_to?(:write) or val.nil?
       @output = val
-      if defined?(Reline::ANSI) and Reline::IOGate == Reline::ANSI
-        Reline::ANSI.output = val
-      end
+      io_gate.output = val
     end
 
     def vi_editing_mode
@@ -217,37 +205,30 @@ module Reline
     end
 
     def get_screen_size
-      Reline::IOGate.get_screen_size
+      io_gate.get_screen_size
     end
 
     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)
@@ -261,20 +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::IOGate.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,27 +263,36 @@ 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)
-      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)
       if ENV['RELINE_STDERR_TTY']
-        if Reline::IOGate.win?
+        if io_gate.win?
           $stderr = File.open(ENV['RELINE_STDERR_TTY'], 'a')
         else
           $stderr.reopen(ENV['RELINE_STDERR_TTY'], 'w')
@@ -310,10 +300,15 @@ module Reline
         $stderr.sync = true
         $stderr.puts "Reline is used by #{Process.pid}"
       end
-      otio = Reline::IOGate.prep
+      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: Reline::IOGate.encoding)
+      key_stroke.encoding = encoding
+      line_editor.reset(prompt)
       if multiline
         line_editor.multiline_on
         if block_given?
@@ -322,164 +317,89 @@ 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
-        Reline::IOGate.set_default_key_bindings(config)
+      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 = Reline::IOGate.in_pasting?
           read_io(config.keyseq_timeout) { |inputs|
-            line_editor.set_pasting_state(Reline::IOGate.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
+                char = io_gate.read_single_char(config.keyseq_timeout.fdiv(1000))
+                key = Reline::Key.new(char || '', :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 Reline::IOGate.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
-        Reline::IOGate.move_cursor_column(0)
+        io_gate.move_cursor_column(0)
       rescue Errno::EIO
         # Maybe the I/O has been closed.
-      rescue StandardError => e
-        line_editor.finalize
-        Reline::IOGate.deprep(otio)
-        raise e
-      rescue Exception
-        # Including Interrupt
+      ensure
         line_editor.finalize
-        Reline::IOGate.deprep(otio)
-        raise
+        io_gate.deprep(otio)
       end
-
-      line_editor.finalize
-      Reline::IOGate.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 = Reline::IOGate.getc
-        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
-        end
-      end
-    end
-
-    private def read_2nd_character_of_key_sequence(keyseq_timeout, buffer, c, block)
-      begin
-        succ_c = nil
-        Timeout.timeout(keyseq_timeout / 1000.0) {
-          succ_c = Reline::IOGate.getc
-        }
-      rescue Timeout::Error # cancel matching only when first byte
-        block.([Reline::Key.new(c, c, false)])
-        return :break
-      else
-        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
-          Reline::IOGate.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
+        else
+          buffer << c
+          status = key_stroke.match_status(buffer)
         end
-      end
-    end
 
-    private def read_escaped_key(keyseq_timeout, c, block)
-      begin
-        escaped_c = nil
-        Timeout.timeout(keyseq_timeout / 1000.0) {
-          escaped_c = Reline::IOGate.getc
-        }
-      rescue Timeout::Error # independent ESC
-        block.([Reline::Key.new(c, c, false)])
-      else
-        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)])
+        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
       end
     end
@@ -490,19 +410,19 @@ module Reline
     end
 
     private def may_req_ambiguous_char_width
-      @ambiguous_width = 2 if Reline::IOGate == Reline::GeneralIO or !STDOUT.tty?
+      @ambiguous_width = 1 if io_gate.dumb? || !STDIN.tty? || !STDOUT.tty?
       return if defined? @ambiguous_width
-      Reline::IOGate.move_cursor_column(0)
+      io_gate.move_cursor_column(0)
       begin
         output.write "\u{25bd}"
       rescue Encoding::UndefinedConversionError
         # LANG=C
         @ambiguous_width = 1
       else
-        @ambiguous_width = Reline::IOGate.cursor_pos.x
+        @ambiguous_width = io_gate.cursor_pos.x == 2 ? 2 : 1
       end
-      Reline::IOGate.move_cursor_column(0)
-      Reline::IOGate.erase_after_cursor
+      io_gate.move_cursor_column(0)
+      io_gate.erase_after_cursor
     end
   end
 
@@ -518,6 +438,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
@@ -538,8 +469,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
 
@@ -553,19 +484,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, Reline::IOGate.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`><=;|&{("
@@ -578,7 +508,7 @@ module Reline
   end
 
   def self.ungetc(c)
-    Reline::IOGate.ungetc(c)
+    core.io_gate.ungetc(c)
   end
 
   def self.line_editor
@@ -586,22 +516,12 @@ module Reline
   end
 end
 
-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
+
+Reline::IOGate = Reline::IO.decide_io_gate
+
+# Deprecated
+Reline::GeneralIO = Reline::Dumb.new # :nodoc:
+
+Reline::Face.load_initial_configs
 
 Reline::HISTORY = Reline::History.new(Reline.core.config)