reline 0.3.0 → 0.3.6

data/lib/reline.rb

@@ -11,12 +11,13 @@ require 'reline/terminfo'
 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
+  Key = Struct.new(:char, :combined_char, :with_meta) do
     def match?(other)
       case other
       when Reline::Key
@@ -33,7 +34,18 @@ module Reline
     alias_method :==, :match?
   end
   CursorPos = Struct.new(:x, :y)
-  DialogRenderInfo = Struct.new(:pos, :contents, :bg_color, :width, :height, :scrollbar, keyword_init: true)
+  DialogRenderInfo = Struct.new(
+    :pos,
+    :contents,
+    :bg_color,
+    :pointer_bg_color,
+    :fg_color,
+    :pointer_fg_color,
+    :width,
+    :height,
+    :scrollbar,
+    keyword_init: true
+  )
 
   class Core
     ATTR_READER_NAMES = %i(
@@ -58,6 +70,11 @@ module Reline
     attr_accessor :last_incremental_search
     attr_reader :output
 
+    extend Forwardable
+    def_delegators :config,
+      :autocompletion,
+      :autocompletion=
+
     def initialize
       self.output = STDOUT
       @dialog_proc_list = {}
@@ -66,44 +83,48 @@ module Reline
       @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)
@@ -123,14 +144,6 @@ module Reline
       @completion_proc = p
     end
 
-    def autocompletion
-      @config.autocompletion
-    end
-
-    def autocompletion=(val)
-      @config.autocompletion = val
-    end
-
     def output_modifier_proc=(p)
       raise ArgumentError unless p.respond_to?(:call) or p.nil?
       @output_modifier_proc = p
@@ -157,9 +170,13 @@ module Reline
 
     DialogProc = Struct.new(:dialog_proc, :context)
     def add_dialog_proc(name_sym, p, context = nil)
-      raise ArgumentError unless p.respond_to?(:call) or p.nil?
       raise ArgumentError unless name_sym.instance_of?(Symbol)
-      @dialog_proc_list[name_sym] = DialogProc.new(p, context)
+      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)
@@ -168,20 +185,16 @@ 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
+      if io_gate.respond_to?(:output=)
+        io_gate.output = val
       end
     end
 
@@ -204,7 +217,7 @@ module Reline
     end
 
     def get_screen_size
-      Reline::IOGate.get_screen_size
+      io_gate.get_screen_size
     end
 
     Reline::DEFAULT_DIALOG_PROC_AUTOCOMPLETE = ->() {
@@ -243,27 +256,40 @@ module Reline
         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)
+      DialogRenderInfo.new(
+        pos: cursor_pos_to_render,
+        contents: result,
+        scrollbar: true,
+        height: [15, preferred_dialog_height].min,
+        bg_color: 46,
+        pointer_bg_color: 45,
+        fg_color: 37,
+        pointer_fg_color: 37
+      )
     }
     Reline::DEFAULT_DIALOG_CONTEXT = Array.new
 
     def readmultiline(prompt = '', add_hist = false, &confirm_multiline_termination)
-      unless confirm_multiline_termination
-        raise ArgumentError.new('#readmultiline needs block to confirm multiline termination')
-      end
-      inner_readline(prompt, add_hist, true, &confirm_multiline_termination)
+      Reline.update_iogate
+      io_gate.with_raw_input 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)
 
-      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
+        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
 
-      line_editor.reset_line if line_editor.whole_buffer.nil?
-      whole_buffer
+        line_editor.reset_line if line_editor.whole_buffer.nil?
+        whole_buffer
+      end
     end
 
     def readline(prompt = '', add_hist = false)
+      Reline.update_iogate
       inner_readline(prompt, add_hist, false)
 
       line = line_editor.line.dup
@@ -278,7 +304,7 @@ module Reline
 
     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')
@@ -286,10 +312,10 @@ module Reline
         $stderr.sync = true
         $stderr.puts "Reline is used by #{Process.pid}"
       end
-      otio = Reline::IOGate.prep
+      otio = io_gate.prep
 
       may_req_ambiguous_char_width
-      line_editor.reset(prompt, encoding: Reline::IOGate.encoding)
+      line_editor.reset(prompt, encoding: encoding)
       if multiline
         line_editor.multiline_on
         if block_given?
@@ -313,7 +339,7 @@ module Reline
       unless config.test_mode
         config.read
         config.reset_default_key_bindings
-        Reline::IOGate.set_default_key_bindings(config)
+        io_gate.set_default_key_bindings(config)
       end
 
       line_editor.rerender
@@ -322,9 +348,9 @@ module Reline
         line_editor.set_signal_handlers
         prev_pasting_state = false
         loop do
-          prev_pasting_state = Reline::IOGate.in_pasting?
+          prev_pasting_state = io_gate.in_pasting?
           read_io(config.keyseq_timeout) { |inputs|
-            line_editor.set_pasting_state(Reline::IOGate.in_pasting?)
+            line_editor.set_pasting_state(io_gate.in_pasting?)
             inputs.each { |c|
               line_editor.input_key(c)
               line_editor.rerender
@@ -334,29 +360,29 @@ module Reline
               @bracketed_paste_finished = false
             end
           }
-          if prev_pasting_state == true and not Reline::IOGate.in_pasting? and not line_editor.finished?
+          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
           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)
+        io_gate.deprep(otio)
         raise e
       rescue Exception
         # Including Interrupt
         line_editor.finalize
-        Reline::IOGate.deprep(otio)
+        io_gate.deprep(otio)
         raise
       end
 
       line_editor.finalize
-      Reline::IOGate.deprep(otio)
+      io_gate.deprep(otio)
     end
 
     # GNU Readline waits for "keyseq-timeout" milliseconds to see if the ESC
@@ -371,7 +397,7 @@ module Reline
     private def read_io(keyseq_timeout, &block)
       buffer = []
       loop do
-        c = Reline::IOGate.getc
+        c = io_gate.getc
         if c == -1
           result = :unmatched
           @bracketed_paste_finished = true
@@ -411,7 +437,7 @@ module Reline
       begin
         succ_c = nil
         Timeout.timeout(keyseq_timeout / 1000.0) {
-          succ_c = Reline::IOGate.getc
+          succ_c = io_gate.getc
         }
       rescue Timeout::Error # cancel matching only when first byte
         block.([Reline::Key.new(c, c, false)])
@@ -426,7 +452,7 @@ module Reline
           end
           return :break
         when :matching
-          Reline::IOGate.ungetc(succ_c)
+          io_gate.ungetc(succ_c)
           return :next
         when :matched
           buffer << succ_c
@@ -443,7 +469,7 @@ module Reline
       begin
         escaped_c = nil
         Timeout.timeout(keyseq_timeout / 1000.0) {
-          escaped_c = Reline::IOGate.getc
+          escaped_c = io_gate.getc
         }
       rescue Timeout::Error # independent ESC
         block.([Reline::Key.new(c, c, false)])
@@ -466,19 +492,19 @@ module Reline
     end
 
     private def may_req_ambiguous_char_width
-      @ambiguous_width = 2 if Reline::IOGate == Reline::GeneralIO or STDOUT.is_a?(File)
+      @ambiguous_width = 2 if io_gate == Reline::GeneralIO or !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
       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
 
@@ -541,7 +567,7 @@ module Reline
     @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.line_editor = Reline::LineEditor.new(core.config, core.encoding)
 
       core.basic_word_break_characters = " \t\n`><=;|&{("
       core.completer_word_break_characters = " \t\n`><=;|&{("
@@ -554,33 +580,42 @@ module Reline
   end
 
   def self.ungetc(c)
-    Reline::IOGate.ungetc(c)
+    core.io_gate.ungetc(c)
   end
 
   def self.line_editor
     core.line_editor
   end
-end
 
-require 'reline/general_io'
-if RbConfig::CONFIG['host_os'] =~ /mswin|msys|mingw|cygwin|bccwin|wince|emc/
-  require 'reline/windows'
-  if Reline::Windows.msys_tty?
-    Reline::IOGate = if ENV['TERM'] == 'dumb'
-      Reline::GeneralIO
-    else
+  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'
-      Reline::ANSI
+      remove_const(:IOGate)
+      const_set(:IOGate, Reline::ANSI)
     end
-  else
-    Reline::IOGate = Reline::Windows
   end
-else
-  Reline::IOGate = if $stdout.isatty
-    require 'reline/ansi'
-    Reline::ANSI
+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
-    Reline::GeneralIO
+    tty = $stdout.tty?
   end
 end
+Reline::IOGate = if tty
+  require 'reline/ansi'
+  Reline::ANSI
+else
+  io
+end
+
 Reline::HISTORY = Reline::History.new(Reline.core.config)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: reline
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.6
 platform: ruby
 authors:
 - aycabta
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-12-24 00:00:00.000000000 Z
+date: 2023-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: io-console
@@ -47,7 +47,6 @@ files:
 - lib/reline/key_stroke.rb
 - lib/reline/kill_ring.rb
 - lib/reline/line_editor.rb
-- lib/reline/sibori.rb
 - lib/reline/terminfo.rb
 - lib/reline/unicode.rb
 - lib/reline/unicode/east_asian_width.rb
@@ -66,14 +65,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.5'
+      version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
+rubygems_version: 3.4.13
 signing_key:
 specification_version: 4
 summary: Alternative GNU Readline or Editline implementation by pure Ruby.

data/lib/reline/sibori.rb

@@ -1,170 +0,0 @@
-require 'reline/unicode'
-
-=begin
-
-  \       |
-   \      | <--- whipped cream
-    \     |
-     \    |
-      \-~~|
-       \  | <--- shibori kutigane (piping nozzle in Japanese)
-        \Ml
-         (\    __ __
-         ( \--(  )  )
-          (__(__)__)  <--- compressed whipped cream
-=end
-
-class Sibori
-  attr_writer :output
-
-  def initialize(width, height, cursor_pos)
-    @width = width
-    @height = height
-    @cursor_pos = cursor_pos
-    @screen = [String.new]
-    @line_index = 0
-    @byte_pointer_in_line = 0
-    @cleared = false
-    clone_screen
-  end
-
-  def clone_screen
-    @prev_screen = @screen.map { |line|
-      line.dup
-    }
-    @prev_cursor_pos = @cursor_pos.dup
-    @prev_line_index = @line_index
-  end
-
-  def print(str)
-    #$stderr.puts "print #{str.inspect}"
-    line = @screen[@line_index]
-    before = line.byteslice(0, @byte_pointer_in_line)
-    str_width = Reline::Unicode.calculate_width(str, true)
-    after_cursor = line.byteslice(@byte_pointer_in_line..-1)
-    after_cursor_width = Reline::Unicode.calculate_width(after_cursor, true)
-    rest = ''
-    if after_cursor_width > str_width
-      rest_byte_pointer = @byte_pointer_in_line + width_to_bytesize(after_cursor, str_width)
-      rest = line.byteslice(rest_byte_pointer..-1)
-    end
-    @screen[@line_index] = before + str + rest
-    @byte_pointer_in_line += str.bytesize
-    @cursor_pos.x += Reline::Unicode.calculate_width(str, true)
-  end
-
-  def move_cursor_column(col)
-    #$stderr.puts "move_cursor_column(#{col})"
-    @byte_pointer_in_line = width_to_bytesize(@screen[@line_index], col)
-    @cursor_pos.x = col
-  end
-
-  def move_cursor_up(val)
-    #$stderr.puts "move_cursor_up(#{val})"
-    if @line_index.positive?
-      @line_index -= val
-      @byte_pointer_in_line = width_to_bytesize(@screen[@line_index], @cursor_pos.x)
-      @cursor_pos.y -= val
-    end
-  end
-
-  def move_cursor_down(val)
-    #$stderr.puts "move_cursor_down(#{val})"
-    if @line_index < @height - 1
-      #$stderr.puts "@line_index #{@line_index}  @screen.size #{@screen.size}  @height #{@height}"
-      #$stderr.puts @screen.inspect
-      @line_index += val
-      @screen[@line_index] = String.new if @line_index == @screen.size
-      @byte_pointer_in_line = width_to_bytesize(@screen[@line_index], @cursor_pos.x)
-      @cursor_pos.y += val
-    end
-  end
-
-  def scroll_down(val)
-    #$stderr.puts "scroll_down(#{val})"
-    if val >= @height
-      clear_screen
-      @line_index = @screen.size - 1
-      return
-    end
-    @screen.size.times do |n|
-      if n < @screen.size - val
-        #$stderr.puts "A @screen[#{val} + #{n}] (#{@screen[val + n].inspect}) to @screen[#{n}]"
-        @screen[n] = @screen[val + n]
-      else
-        #$stderr.puts "B String.new to @screen[#{n}]"
-        @screen[n] = String.new
-      end
-    end
-    @line_index += val
-  end
-
-  def erase_after_cursor
-    #$stderr.puts "erase_after_cursor"
-    @screen[@line_index] = @screen[@line_index].byteslice(0, @byte_pointer_in_line)
-  end
-
-  def clear_screen
-    #$stderr.puts "clear_screen"
-    @screen = [String.new]
-    @line_index = 0
-    @byte_pointer_in_line = 0
-    @cursor_pos.x = @cursor_pos.y = 0
-    @cleared = true
-    Reline::IOGate.clear_screen
-  end
-
-  private def width_to_bytesize(str, width)
-    lines, _ = Reline::Unicode.split_by_width(str, width)
-    lines.first.bytesize
-  end
-
-  def render
-    #$stderr.puts ?* * 100
-    Reline::IOGate.move_cursor_up(@prev_line_index) if @prev_line_index.positive?
-    #$stderr.puts "! move_cursor_up(#{@prev_line_index})" if @prev_line_index.positive?
-    #$stderr.puts "@prev_line_index #{@prev_line_index}  @line_index #{@line_index}"
-    if @screen.size > @prev_screen.size
-    #$stderr.puts ?a * 100
-      down = @screen.size - @prev_screen.size
-      #$stderr.puts "#{@prev_cursor_pos.y} #{down} #{@height}"
-      if @prev_cursor_pos.y + down > (@height - 1)
-    #$stderr.puts ?b * 100
-        scroll = (@prev_cursor_pos.y + down) - (@height - 1)
-        Reline::IOGate.scroll_down(scroll)
-        #$stderr.puts "! scroll_down(#{scroll})"
-    #$stderr.puts "down #{down}"
-        Reline::IOGate.move_cursor_up(@screen.size - 1 - scroll)
-        #$stderr.puts "! move_cursor_up(#{@screen.size - 1})"
-      else
-    #$stderr.puts ?c * 100
-      end
-    end
-    @screen.size.times do |n|
-      Reline::IOGate.move_cursor_column(0)
-      #$stderr.puts "! move_cursor_column(0)"
-      @output.write @screen[n]
-      #$stderr.puts "! print #{@screen[n].inspect}"
-      Reline::IOGate.erase_after_cursor
-      #$stderr.puts "! erase_after_cursor"
-      Reline::IOGate.move_cursor_down(1) if n != (@screen.size - 1)
-      #$stderr.puts "! move_cursor_down(1)" if n != (@screen.size - 1)
-    end
-    up = @screen.size - 1 - @line_index
-    Reline::IOGate.move_cursor_up(up) if up.positive?
-    #$stderr.puts "! move_cursor_up(#{up})" if up.positive?
-    column = Reline::Unicode.calculate_width(@screen[@line_index].byteslice(0, @byte_pointer_in_line), true)
-    Reline::IOGate.move_cursor_column(column)
-    #$stderr.puts "! move_cursor_column(#{column}) #{@byte_pointer_in_line}"
-    clone_screen
-    #$stderr.puts ?- * 10
-  end
-
-  def prep
-    Reline::IOGate.prep
-  end
-
-  def deprep
-    Reline::IOGate.deprep
-  end
-end