llm-shell 0.10.0 → 0.11.0

data/lib/llm/shell/internal/reline/lib/reline.rb

@@ -1,527 +0,0 @@
-require 'io/console'
-require 'forwardable'
-require 'reline/version'
-require 'reline/config'
-require 'reline/key_actor'
-require 'reline/key_stroke'
-require 'reline/line_editor'
-require 'reline/history'
-require 'reline/io'
-require 'reline/face'
-require 'rbconfig'
-
-module Reline
-  # NOTE: For making compatible with the rb-readline gem
-  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
-  end # :nodoc:
-  CursorPos = Struct.new(:x, :y) # :nodoc:
-  DialogRenderInfo = Struct.new(
-    :pos,
-    :contents,
-    :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(
-      completion_append_character
-      basic_word_break_characters
-      completer_word_break_characters
-      basic_quote_characters
-      completer_quote_characters
-      filename_quote_characters
-      special_prefixes
-      completion_proc
-      output_modifier_proc
-      prompt_proc
-      auto_indent_proc
-      pre_input_hook
-      dig_perfect_match_proc
-    ).each(&method(:attr_reader))
-
-    attr_accessor :config
-    attr_accessor :key_stroke
-    attr_accessor :line_editor
-    attr_accessor :last_incremental_search
-    attr_reader :output
-
-    extend Forwardable
-    def_delegators :config,
-      :autocompletion,
-      :autocompletion=
-
-    def initialize
-      self.output = STDOUT
-      @mutex = Mutex.new
-      @dialog_proc_list = {}
-      yield self
-      @completion_quote_character = nil
-    end
-
-    def io_gate
-      Reline::IOGate
-    end
-
-    def 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(encoding)
-      elsif val.size > 1
-        @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(encoding)
-    end
-
-    def completer_word_break_characters=(v)
-      @completer_word_break_characters = v.encode(encoding)
-    end
-
-    def basic_quote_characters=(v)
-      @basic_quote_characters = v.encode(encoding)
-    end
-
-    def completer_quote_characters=(v)
-      @completer_quote_characters = v.encode(encoding)
-    end
-
-    def filename_quote_characters=(v)
-      @filename_quote_characters = v.encode(encoding)
-    end
-
-    def special_prefixes=(v)
-      @special_prefixes = v.encode(encoding)
-    end
-
-    def completion_case_fold=(v)
-      @config.completion_ignore_case = v
-    end
-
-    def completion_case_fold
-      @config.completion_ignore_case
-    end
-
-    def completion_quote_character
-      @completion_quote_character
-    end
-
-    def completion_proc=(p)
-      raise ArgumentError unless p.respond_to?(:call) or p.nil?
-      @completion_proc = p
-    end
-
-    def output_modifier_proc=(p)
-      raise ArgumentError unless p.respond_to?(:call) or p.nil?
-      @output_modifier_proc = p
-    end
-
-    def prompt_proc=(p)
-      raise ArgumentError unless p.respond_to?(:call) or p.nil?
-      @prompt_proc = p
-    end
-
-    def auto_indent_proc=(p)
-      raise ArgumentError unless p.respond_to?(:call) or p.nil?
-      @auto_indent_proc = p
-    end
-
-    def pre_input_hook=(p)
-      @pre_input_hook = p
-    end
-
-    def dig_perfect_match_proc=(p)
-      raise ArgumentError unless p.respond_to?(:call) or p.nil?
-      @dig_perfect_match_proc = p
-    end
-
-    DialogProc = Struct.new(:dialog_proc, :context)
-    def add_dialog_proc(name_sym, p, context = nil)
-      raise ArgumentError unless name_sym.instance_of?(Symbol)
-      if p.nil?
-        @dialog_proc_list.delete(name_sym)
-      else
-        raise ArgumentError unless p.respond_to?(:call)
-        @dialog_proc_list[name_sym] = DialogProc.new(p, context)
-      end
-    end
-
-    def dialog_proc(name_sym)
-      @dialog_proc_list[name_sym]
-    end
-
-    def input=(val)
-      raise TypeError unless val.respond_to?(:getc) or val.nil?
-      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
-      io_gate.output = val
-    end
-
-    def vi_editing_mode
-      config.editing_mode = :vi_insert
-      nil
-    end
-
-    def emacs_editing_mode
-      config.editing_mode = :emacs
-      nil
-    end
-
-    def vi_editing_mode?
-      config.editing_mode_is?(:vi_insert, :vi_command)
-    end
-
-    def emacs_editing_mode?
-      config.editing_mode_is?(:emacs)
-    end
-
-    def get_screen_size
-      io_gate.get_screen_size
-    end
-
-    Reline::DEFAULT_DIALOG_PROC_AUTOCOMPLETE = ->() {
-      # autocomplete
-      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)
-      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)
-      if context and context.is_a?(Array)
-        context.clear
-        context.push(cursor_pos_to_render, result, pointer, dialog)
-      end
-      dialog.pointer = pointer
-      DialogRenderInfo.new(
-        pos: cursor_pos_to_render,
-        contents: result,
-        scrollbar: true,
-        height: [15, preferred_dialog_height].min,
-        face: :completion_dialog
-      )
-    } # :nodoc:
-    Reline::DEFAULT_DIALOG_CONTEXT = Array.new # :nodoc:
-
-    def readmultiline(prompt = '', add_hist = false, &confirm_multiline_termination)
-      @mutex.synchronize do
-        unless confirm_multiline_termination
-          raise ArgumentError.new('#readmultiline needs block to confirm multiline termination')
-        end
-
-        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'
-        if add_hist and whole_buffer and whole_buffer.chomp("\n").size > 0
-          Reline::HISTORY << whole_buffer
-        end
-
-        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)
-      @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_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 io_gate.win?
-          $stderr = File.open(ENV['RELINE_STDERR_TTY'], 'a')
-        else
-          $stderr.reopen(ENV['RELINE_STDERR_TTY'], 'w')
-        end
-        $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
-      key_stroke.encoding = encoding
-      line_editor.reset(prompt)
-      if multiline
-        line_editor.multiline_on
-        if block_given?
-          line_editor.confirm_multiline_termination_proc = confirm_multiline_termination
-        end
-      else
-        line_editor.multiline_off
-      end
-      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
-
-      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
-        loop do
-          read_io(config.keyseq_timeout) { |inputs|
-            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 line_editor.finished?
-            line_editor.render_finished
-            break
-          else
-            line_editor.rerender
-          end
-        end
-        io_gate.move_cursor_column(0)
-      rescue Errno::EIO
-        # Maybe the I/O has been closed.
-      ensure
-        line_editor.finalize
-        io_gate.deprep(otio)
-      end
-    end
-
-    # 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
-        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
-            status = KeyStroke::UNMATCHED
-          end
-        else
-          buffer << c
-          status = key_stroke.match_status(buffer)
-        end
-
-        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
-
-    def ambiguous_width
-      may_req_ambiguous_char_width unless defined? @ambiguous_width
-      @ambiguous_width
-    end
-
-    private def may_req_ambiguous_char_width
-      @ambiguous_width = 1 if io_gate.dumb? || !STDIN.tty? || !STDOUT.tty?
-      return if defined? @ambiguous_width
-      io_gate.move_cursor_column(0)
-      begin
-        output.write "\u{25bd}"
-      rescue Encoding::UndefinedConversionError
-        # LANG=C
-        @ambiguous_width = 1
-      else
-        @ambiguous_width = io_gate.cursor_pos.x == 2 ? 2 : 1
-      end
-      io_gate.move_cursor_column(0)
-      io_gate.erase_after_cursor
-    end
-  end
-
-  extend Forwardable
-  extend SingleForwardable
-
-  #--------------------------------------------------------
-  # Documented API
-  #--------------------------------------------------------
-
-  (Core::ATTR_READER_NAMES).each { |name|
-    def_single_delegators :core, :"#{name}", :"#{name}="
-  }
-  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
-  def_instance_delegators self, :readline
-  private :readline
-
-
-  #--------------------------------------------------------
-  # Undocumented API
-  #--------------------------------------------------------
-
-  # Testable in original
-  def_single_delegators :core, :get_screen_size
-  def_single_delegators :line_editor, :eof?
-  def_instance_delegators self, :eof?
-  def_single_delegators :line_editor, :delete_text
-  def_single_delegator :line_editor, :line, :line_buffer
-  def_single_delegator :line_editor, :byte_pointer, :point
-  def_single_delegator :line_editor, :byte_pointer=, :point=
-
-  def self.insert_text(text)
-    line_editor.insert_multiline_text(text)
-    self
-  end
-
-  # Untestable in original
-  def_single_delegator :line_editor, :rerender, :redisplay
-  def_single_delegators :core, :vi_editing_mode?, :emacs_editing_mode?
-  def_single_delegators :core, :ambiguous_width
-  def_single_delegators :core, :last_incremental_search
-  def_single_delegators :core, :last_incremental_search=
-  def_single_delegators :core, :add_dialog_proc
-  def_single_delegators :core, :dialog_proc
-  def_single_delegators :core, :autocompletion, :autocompletion=
-
-  def_instance_delegators self, :readmultiline
-  private :readmultiline
-
-  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.encoding)
-      core.line_editor = Reline::LineEditor.new(core.config)
-
-      core.basic_word_break_characters = " \t\n`><=;|&{("
-      core.completer_word_break_characters = " \t\n`><=;|&{("
-      core.basic_quote_characters = '"\''
-      core.completer_quote_characters = '"\''
-      core.filename_quote_characters = ""
-      core.special_prefixes = ""
-      core.add_dialog_proc(:autocomplete, Reline::DEFAULT_DIALOG_PROC_AUTOCOMPLETE, Reline::DEFAULT_DIALOG_CONTEXT)
-    }
-  end
-
-  def self.ungetc(c)
-    core.io_gate.ungetc(c)
-  end
-
-  def self.line_editor
-    core.line_editor
-  end
-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)