Refactoring Reline.

lib/reline.rb

@@ -1,5 +1,6 @@
 require 'io/console'
 require 'timeout'
+require 'forwardable'
 require 'reline/version'
 require 'reline/config'
 require 'reline/key_actor'
@@ -8,399 +9,391 @@ require 'reline/line_editor'
 require 'reline/history'
 
 module Reline
-  Key = Struct.new('Key', :char, :combined_char, :with_meta)
-
-  extend self
   FILENAME_COMPLETION_PROC = nil
   USERNAME_COMPLETION_PROC = nil
 
-  if RbConfig::CONFIG['host_os'] =~ /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+  Key = Struct.new('Key', :char, :combined_char, :with_meta)
-    IS_WINDOWS = true
-  else
-    IS_WINDOWS = false
-  end
-
   CursorPos = Struct.new(:x, :y)
 
-  @@config = Reline::Config.new
+  class Core
-  @@key_stroke = Reline::KeyStroke.new(@@config)
+    if RbConfig::CONFIG['host_os'] =~ /mswin|msys|mingw|cygwin|bccwin|wince|emc/
-  @@line_editor = Reline::LineEditor.new(@@config)
+      IS_WINDOWS = true
-  @@ambiguous_width = nil
-
-  HISTORY = History.new(@@config)
-
-  @@completion_append_character = nil
-  def self.completion_append_character
-    @@completion_append_character
-  end
-  def self.completion_append_character=(val)
-    if val.nil?
-      @@completion_append_character = nil
-    elsif val.size == 1
-      @@completion_append_character = val.encode(Encoding::default_external)
-    elsif val.size > 1
-      @@completion_append_character = val[0].encode(Encoding::default_external)
     else
-      @@completion_append_character = nil
+      IS_WINDOWS = false
+    end
+
+    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)).freeze
+
+    ATTR_ACCESSOR_NAMES = %i(
+      completion_case_fold
+    ).each(&method(:attr_accessor)).freeze
+
+    attr_accessor :config
+    attr_accessor :key_stroke
+    attr_accessor :line_editor
+    attr_accessor :ambiguous_width
+    attr_reader :output
+
+    def initialize
+      self.output = STDOUT
+      yield self
+    end
+
+    def completion_append_character=(val)
+      if val.nil?
+        @completion_append_character = nil
+      elsif val.size == 1
+        @completion_append_character = val.encode(Encoding::default_external)
+      elsif val.size > 1
+        @completion_append_character = val[0].encode(Encoding::default_external)
+      else
+        @completion_append_character = nil
+      end
+    end
+
+    def basic_word_break_characters=(v)
+      @basic_word_break_characters = v.encode(Encoding::default_external)
+    end
+
+    def completer_word_break_characters=(v)
+      @completer_word_break_characters = v.encode(Encoding::default_external)
+    end
+
+    def basic_quote_characters=(v)
+      @basic_quote_characters = v.encode(Encoding::default_external)
+    end
+
+    def completer_quote_characters=(v)
+      @completer_quote_characters = v.encode(Encoding::default_external)
+    end
+
+    def filename_quote_characters=(v)
+      @filename_quote_characters = v.encode(Encoding::default_external)
+    end
+
+    def special_prefixes=(v)
+      @special_prefixes = v.encode(Encoding::default_external)
+    end
+
+    def completion_proc=(p)
+      raise ArgumentError unless p.is_a?(Proc)
+      @completion_proc = p
+    end
+
+    def output_modifier_proc=(p)
+      raise ArgumentError unless p.is_a?(Proc)
+      @output_modifier_proc = p
+    end
+
+    def prompt_proc=(p)
+      raise ArgumentError unless p.is_a?(Proc)
+      @prompt_proc = p
+    end
+
+    def auto_indent_proc=(p)
+      raise ArgumentError unless p.is_a?(Proc)
+      @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.is_a?(Proc)
+      @dig_perfect_match_proc = p
+    end
+
+    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
+      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
+    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
+      Reline::IOGate.get_screen_size
+    end
+
+    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)
+
+      whole_buffer = line_editor.whole_buffer.dup
+      whole_buffer.taint
+      if add_hist and whole_buffer and whole_buffer.chomp.size > 0
+        Reline::HISTORY << whole_buffer
+      end
+
+      line_editor.reset_line if line_editor.whole_buffer.nil?
+      whole_buffer
+    end
+
+    def readline(prompt = '', add_hist = false)
+      inner_readline(prompt, add_hist, false)
+
+      line = line_editor.line.dup
+      line.taint
+      if add_hist and line and line.chomp.size > 0
+        Reline::HISTORY << line.chomp
+      end
+
+      line_editor.reset_line if line_editor.line.nil?
+      line
+    end
+
+    private
+
+    def inner_readline(prompt, add_hist, multiline, &confirm_multiline_termination)
+      if ENV['RELINE_STDERR_TTY']
+        $stderr.reopen(ENV['RELINE_STDERR_TTY'], 'w')
+        $stderr.sync = true
+        $stderr.puts "Reline is used by #{Process.pid}"
+      end
+      otio = Reline::IOGate.prep
+
+      may_req_ambiguous_char_width
+      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.output = output
+      line_editor.completion_proc = completion_proc
+      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
+      line_editor.rerender
+
+      unless config.test_mode
+        config.read
+        config.reset_default_key_bindings
+        Reline::IOGate::RAW_KEYSTROKE_CONFIG.each_pair do |key, func|
+          config.add_default_key_binding(key, func)
+        end
+      end
+
+      begin
+        loop do
+          read_io(config.keyseq_timeout) { |inputs|
+            inputs.each { |c|
+              line_editor.input_key(c)
+              line_editor.rerender
+            }
+          }
+          break if line_editor.finished?
+        end
+        Reline::IOGate.move_cursor_column(0)
+      rescue StandardError => e
+        line_editor.finalize
+        Reline::IOGate.deprep(otio)
+        raise e
+      end
+
+      line_editor.finalize
+      Reline::IOGate.deprep(otio)
+    end
+
+    # Keystrokes of GNU Readline will timeout it with the specification of
+    # "keyseq-timeout" when waiting for the 2nd character after the 1st one.
+    # If the 2nd character comes after 1st ESC without timeout it has a
+    # meta-property of meta-key to discriminate modified key with meta-key
+    # from multibyte characters that come with 8th bit on.
+    #
+    # GNU Readline will wait for the 2nd character with "keyseq-timeout"
+    # milli-seconds but wait forever after 3rd characters.
+    def read_io(keyseq_timeout, &block)
+      buffer = []
+      loop do
+        c = Reline::IOGate.getc
+        buffer << c
+        result = key_stroke.match_status(buffer)
+        case result
+        when :matched
+          block.(key_stroke.expand(buffer).map{ |c| Reline::Key.new(c, c, false) })
+          break
+        when :matching
+          if buffer.size == 1
+            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)])
+              break
+            else
+              if key_stroke.match_status(buffer.dup.push(succ_c)) == :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
+                break
+              else
+                Reline::IOGate.ungetc(succ_c)
+              end
+            end
+          end
+        when :unmatched
+          if buffer.size == 1 and c == "\e".ord
+            read_escaped_key(keyseq_timeout, buffer, block)
+          else
+            block.(buffer.map{ |c| Reline::Key.new(c, c, false) })
+          end
+          break
+        end
+      end
+    end
+
+    def read_escaped_key(keyseq_timeout, buffer, 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)])
+        end
+      end
+    end
+
+    def may_req_ambiguous_char_width
+      ambiguous_width = 2 if Reline::IOGate == Reline::GeneralIO or STDOUT.is_a?(File)
+      return if ambiguous_width
+      Reline::IOGate.move_cursor_column(0)
+      print "\u{25bd}"
+      ambiguous_width = Reline::IOGate.cursor_pos.x
+      Reline::IOGate.move_cursor_column(0)
+      Reline::IOGate.erase_after_cursor
     end
   end
 
-  @@basic_word_break_characters = " \t\n`><=;|&{("
+  extend SingleForwardable
-  def self.basic_word_break_characters
-    @@basic_word_break_characters
-  end
-  def self.basic_word_break_characters=(v)
-    @@basic_word_break_characters = v.encode(Encoding::default_external)
-  end
 
-  @@completer_word_break_characters = @@basic_word_break_characters.dup
+  #--------------------------------------------------------
-  def self.completer_word_break_characters
+  # Documented API
-    @@completer_word_break_characters
+  #--------------------------------------------------------
-  end
-  def self.completer_word_break_characters=(v)
-    @@completer_word_break_characters = v.encode(Encoding::default_external)
-  end
 
-  @@basic_quote_characters = '"\''
+  (Core::ATTR_READER_NAMES + Core::ATTR_ACCESSOR_NAMES).each { |name|
-  def self.basic_quote_characters
+    def_delegators :core, "#{name}", "#{name}="
-    @@basic_quote_characters
+  }
-  end
+  def_delegators :core, :input=, :output=
-  def self.basic_quote_characters=(v)
+  def_delegators :core, :vi_editing_mode, :emacs_editing_mode
-    @@basic_quote_characters = v.encode(Encoding::default_external)
+  def_delegators :core, :readline
-  end
 
-  @@completer_quote_characters = '"\''
-  def self.completer_quote_characters
-    @@completer_quote_characters
-  end
-  def self.completer_quote_characters=(v)
-    @@completer_quote_characters = v.encode(Encoding::default_external)
-  end
 
-  @@filename_quote_characters = ''
+  #--------------------------------------------------------
-  def self.filename_quote_characters
+  # Undocumented API
-    @@filename_quote_characters
+  #--------------------------------------------------------
-  end
-  def self.filename_quote_characters=(v)
-    @@filename_quote_characters = v.encode(Encoding::default_external)
-  end
 
-  @@special_prefixes = ''
+  # Testable in original
-  def self.special_prefixes
+  def_delegators :core, :get_screen_size
-    @@special_prefixes
+  def_delegators :line_editor, :delete_text
-  end
+  def_delegator :line_editor, :line, :line_buffer
-  def self.special_prefixes=(v)
+  def_delegator :line_editor, :byte_pointer, :point
-    @@special_prefixes = v.encode(Encoding::default_external)
+  def_delegator :line_editor, :byte_pointer=, :point=
-  end
 
-  @@completion_case_fold = nil
+  def self.insert_text(*args, &block)
-  def self.completion_case_fold
+    line_editor.insert_text(*args, &block)
-    @@completion_case_fold
-  end
-  def self.completion_case_fold=(v)
-    @@completion_case_fold = v
-  end
-
-  @@completion_proc = nil
-  def self.completion_proc
-    @@completion_proc
-  end
-  def self.completion_proc=(p)
-    raise ArgumentError unless p.is_a?(Proc)
-    @@completion_proc = p
-  end
-
-  @@output_modifier_proc = nil
-  def self.output_modifier_proc
-    @@output_modifier_proc
-  end
-  def self.output_modifier_proc=(p)
-    raise ArgumentError unless p.is_a?(Proc)
-    @@output_modifier_proc = p
-  end
-
-  @@prompt_proc = nil
-  def self.prompt_proc
-    @@prompt_proc
-  end
-  def self.prompt_proc=(p)
-    raise ArgumentError unless p.is_a?(Proc)
-    @@prompt_proc = p
-  end
-
-  @@auto_indent_proc = nil
-  def self.auto_indent_proc
-    @@auto_indent_proc
-  end
-  def self.auto_indent_proc=(p)
-    raise ArgumentError unless p.is_a?(Proc)
-    @@auto_indent_proc = p
-  end
-
-  @@pre_input_hook = nil
-  def self.pre_input_hook
-    @@pre_input_hook
-  end
-  def self.pre_input_hook=(p)
-    @@pre_input_hook = p
-  end
-
-  @@dig_perfect_match_proc = nil
-  def self.dig_perfect_match_proc
-    @@dig_perfect_match_proc
-  end
-  def self.dig_perfect_match_proc=(p)
-    raise ArgumentError unless p.is_a?(Proc)
-    @@dig_perfect_match_proc = p
-  end
-
-  def self.insert_text(text)
-    @@line_editor&.insert_text(text)
     self
   end
 
-  def self.redisplay
+  # Untestable in original
-    @@line_editor&.rerender
+  def_delegator :line_editor, :rerender, :redisplay
+  def_delegators :core, :vi_editing_mode?, :emacs_editing_mode?
+  def_delegators :core, :ambiguous_width
+
+  def_delegators :core, :readmultiline
+
+  private
+
+  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.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 = ""
+    }
   end
 
-  def self.line_buffer
+  def self.line_editor
-    @@line_editor&.line
+    core.line_editor
   end
 
-  def self.point
+  HISTORY = History.new(core.config)
-    @@line_editor ? @@line_editor.byte_pointer : 0
-  end
-
-  def self.point=(val)
-    @@line_editor.byte_pointer = val
-  end
-
-  def self.delete_text(start = nil, length = nil)
-    @@line_editor&.delete_text(start, length)
-  end
-
-  def self.input=(val)
-    raise TypeError unless val.respond_to?(:getc) or val.nil?
-    if val.respond_to?(:getc)
-      if defined?(Reline::ANSI) and IOGate == Reline::ANSI
-        Reline::ANSI.input = val
-      elsif IOGate == Reline::GeneralIO
-        Reline::GeneralIO.input = val
-      end
-    end
-  end
-
-  @@output = STDOUT
-  def self.output=(val)
-    raise TypeError unless val.respond_to?(:write) or val.nil?
-    @@output = val
-    if defined?(Reline::ANSI) and IOGate == Reline::ANSI
-      Reline::ANSI.output = val
-    end
-  end
-
-  def self.vi_editing_mode
-    @@config.editing_mode = :vi_insert
-    nil
-  end
-
-  def self.emacs_editing_mode
-    @@config.editing_mode = :emacs
-    nil
-  end
-
-  def self.vi_editing_mode?
-    @@config.editing_mode_is?(:vi_insert, :vi_command)
-  end
-
-  def self.emacs_editing_mode?
-    @@config.editing_mode_is?(:emacs)
-  end
-
-  def self.get_screen_size
-    Reline::IOGate.get_screen_size
-  end
-
-  def eof?
-    @@line_editor.eof?
-  end
-
-  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)
-
-    whole_buffer = @@line_editor.whole_buffer.dup
-    whole_buffer.taint
-    if add_hist and whole_buffer and whole_buffer.chomp.size > 0
-      Reline::HISTORY << whole_buffer
-    end
-
-    @@line_editor.reset_line if @@line_editor.whole_buffer.nil?
-    whole_buffer
-  end
-
-  def readline(prompt = '', add_hist = false)
-    inner_readline(prompt, add_hist, false)
-
-    line = @@line_editor.line.dup
-    line.taint
-    if add_hist and line and line.chomp.size > 0
-      Reline::HISTORY << line.chomp
-    end
-
-    @@line_editor.reset_line if @@line_editor.line.nil?
-    line
-  end
-
-  def inner_readline(prompt, add_hist, multiline, &confirm_multiline_termination)
-    if ENV['RELINE_STDERR_TTY']
-      $stderr.reopen(ENV['RELINE_STDERR_TTY'], 'w')
-      $stderr.sync = true
-      $stderr.puts "Reline is used by #{Process.pid}"
-    end
-    otio = Reline::IOGate.prep
-
-    may_req_ambiguous_char_width
-    @@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.output = @@output
-    @@line_editor.completion_proc = @@completion_proc
-    @@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
-    @@line_editor.rerender
-
-    unless @@config.test_mode
-      @@config.read
-      @@config.reset_default_key_bindings
-      Reline::IOGate::RAW_KEYSTROKE_CONFIG.each_pair do |key, func|
-        @@config.add_default_key_binding(key, func)
-      end
-    end
-
-    begin
-      loop do
-        read_io(@@config.keyseq_timeout) { |inputs|
-          inputs.each { |c|
-            @@line_editor.input_key(c)
-            @@line_editor.rerender
-          }
-        }
-        break if @@line_editor.finished?
-      end
-      Reline::IOGate.move_cursor_column(0)
-    rescue StandardError => e
-      @@line_editor.finalize
-      Reline::IOGate.deprep(otio)
-      raise e
-    end
-
-    @@line_editor.finalize
-    Reline::IOGate.deprep(otio)
-  end
-
-  # Keystrokes of GNU Readline will timeout it with the specification of
-  # "keyseq-timeout" when waiting for the 2nd character after the 1st one.
-  # If the 2nd character comes after 1st ESC without timeout it has a
-  # meta-property of meta-key to discriminate modified key with meta-key
-  # from multibyte characters that come with 8th bit on.
-  #
-  # GNU Readline will wait for the 2nd character with "keyseq-timeout"
-  # milli-seconds but wait forever after 3rd characters.
-  def read_io(keyseq_timeout, &block)
-    buffer = []
-    loop do
-      c = Reline::IOGate.getc
-      buffer << c
-      result = @@key_stroke.match_status(buffer)
-      case result
-      when :matched
-        block.(@@key_stroke.expand(buffer).map{ |c| Reline::Key.new(c, c, false) })
-        break
-      when :matching
-        if buffer.size == 1
-          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)])
-            break
-          else
-            if @@key_stroke.match_status(buffer.dup.push(succ_c)) == :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
-              break
-            else
-              Reline::IOGate.ungetc(succ_c)
-            end
-          end
-        end
-      when :unmatched
-        if buffer.size == 1 and c == "\e".ord
-          read_escaped_key(keyseq_timeout, buffer, block)
-        else
-          block.(buffer.map{ |c| Reline::Key.new(c, c, false) })
-        end
-        break
-      end
-    end
-  end
-
-  def read_escaped_key(keyseq_timeout, buffer, 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)])
-      end
-    end
-  end
-
-  def may_req_ambiguous_char_width
-    @@ambiguous_width = 2 if Reline::IOGate == Reline::GeneralIO or STDOUT.is_a?(File)
-    return if @@ambiguous_width
-    Reline::IOGate.move_cursor_column(0)
-    print "\u{25bd}"
-    @@ambiguous_width = Reline::IOGate.cursor_pos.x
-    Reline::IOGate.move_cursor_column(0)
-    Reline::IOGate.erase_after_cursor
-  end
-
-  def self.ambiguous_width
-    @@ambiguous_width
-  end
 end
 
-if Reline::IS_WINDOWS
+if Reline::Core::IS_WINDOWS
   require 'reline/windows'
-  Reline::IOGate = Reline::Windows
+  Reline::IOGate = Reline::Core::Windows
 else
   require 'reline/ansi'
   Reline::IOGate = Reline::ANSI

lib/reline2.rb

@@ -1,133 +0,0 @@
-require 'io/console'
-require 'timeout'
-require "forwardable"
-require 'reline/version'
-require 'reline/config'
-require 'reline/key_actor'
-require 'reline/key_stroke'
-require 'reline/line_editor'
-
-module Reline2
-  FILENAME_COMPLETION_PROC = nil
-  USERNAME_COMPLETION_PROC = nil
-
-  class Core
-    Key = Struct.new('Key', :char, :combined_char, :with_meta)
-    if RUBY_PLATFORM =~ /mswin|mingw/
-      IS_WINDOWS = true
-    else
-      IS_WINDOWS = false
-    end
-
-    CursorPos = Struct.new(:x, :y)
-
-    ATTR_ACCESSOR_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_case_fold
-      completion_proc
-      output_modifier_proc
-      prompt_proc
-      auto_indent_proc
-      pre_input_hook
-      dig_perfect_match_proc
-    ).freeze
-    ATTR_ACCESSOR_NAMES.each &method(:attr_accessor)
-
-    def initialize
-      @config = Reline::Config.new
-      @line_editor = Reline::LineEditor.new(@config)
-      @ambiguous_width = nil
-
-      self.basic_word_break_characters = " \t\n`><=;|&{("
-      self.completer_word_break_characters = " \t\n`><=;|&{("
-      self.basic_quote_characters = '"\''
-      self.completer_quote_characters = '"\''
-      self.filename_quote_characters = ""
-      self.special_prefixes = ""
-    end
-
-    def completion_append_character=(val)
-      if val.nil?
-        @completion_append_character = nil
-      elsif val.size == 1
-        @completion_append_character = val.encode(Encoding::default_external)
-      elsif val.size > 1
-        @completion_append_character = val[0].encode(Encoding::default_external)
-      else
-        @completion_append_character = nil
-      end
-    end
-
-    def basic_word_break_characters=(v)
-      @basic_word_break_characters = v.encode(Encoding::default_external)
-    end
-
-    def completer_word_break_characters=(v)
-      @completer_word_break_characters = v.encode(Encoding::default_external)
-    end
-
-    def basic_quote_characters=(v)
-      @basic_quote_characters = v.encode(Encoding::default_external)
-    end
-
-    def completer_quote_characters=(v)
-      @completer_quote_characters = v.encode(Encoding::default_external)
-    end
-
-    def filename_quote_characters=(v)
-      @filename_quote_characters = v.encode(Encoding::default_external)
-    end
-
-    def special_prefixes=(v)
-      @special_prefixes = v.encode(Encoding::default_external)
-    end
-
-    def completion_proc=(p)
-      raise ArgumentError unless p.is_a?(Proc)
-      @completion_proc = p
-    end
-
-    def output_modifier_proc=(p)
-      raise ArgumentError unless p.is_a?(Proc)
-      @output_modifier_proc = p
-    end
-
-    def prompt_proc=(p)
-      raise ArgumentError unless p.is_a?(Proc)
-      @prompt_proc = p
-    end
-
-    def auto_indent_proc=(p)
-      raise ArgumentError unless p.is_a?(Proc)
-      @auto_indent_proc = p
-    end
-
-    def pre_input_hook=(p)
-      raise ArgumentError unless p.is_a?(Proc)
-      @pre_input_hook = p
-    end
-
-    def dig_perfect_match_proc=(p)
-      raise ArgumentError unless p.is_a?(Proc)
-      @dig_perfect_match_proc = p
-    end
-  end
-
-  extend SingleForwardable
-
-  Core::ATTR_ACCESSOR_NAMES.each { |name|
-    def_delegators :core, "#{name}", "#{name}="
-  }
-
-  private
-
-  def self.core
-    @core ||= Core.new
-  end
-end

test/reline/helper.rb

@@ -1,6 +1,5 @@
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 require 'reline'
-require 'reline2'
 require 'test/unit'
 
 module Reline
@@ -8,8 +7,12 @@ module Reline
     def test_mode
         remove_const('IOGate') if const_defined?('IOGate')
         const_set('IOGate', Reline::GeneralIO)
-        @@config.instance_variable_set(:@test_mode, true)
+        send(:core).config.instance_variable_set(:@test_mode, true)
-        @@config.reset
+        send(:core).config.reset
+    end
+
+    def test_reset
+      Reline.instance_variable_set(:@core, nil)
     end
   end
 end

test/test_reline2.rb

@@ -1,174 +0,0 @@
-require_relative 'helper'
-require "reline2"
-
-class Reline2::Test < Reline::TestCase
-  def test_completion_append_character
-    assert_equal(Reline2.completion_append_character, nil)
-
-    Reline2.completion_append_character = ""
-    assert_equal(Reline2.completion_append_character, nil)
-
-    Reline2.completion_append_character = "a"
-    assert_equal(Reline2.completion_append_character, "a")
-    assert_equal(Reline2.completion_append_character.encoding, Encoding::default_external)
-
-    Reline2.completion_append_character = "ba"
-    assert_equal(Reline2.completion_append_character, "b")
-    assert_equal(Reline2.completion_append_character.encoding, Encoding::default_external)
-
-    Reline2.completion_append_character = "cba"
-    assert_equal(Reline2.completion_append_character, "c")
-    assert_equal(Reline2.completion_append_character.encoding, Encoding::default_external)
-
-    Reline2.completion_append_character = nil
-    assert_equal(Reline2.completion_append_character, nil)
-  end
-
-  def test_basic_word_break_characters
-    assert_equal(Reline2.basic_word_break_characters, " \t\n`><=;|&{(")
-
-    Reline2.basic_word_break_characters = "ああ"
-    assert_equal(Reline2.basic_word_break_characters, "ああ")
-    assert_equal(Reline2.basic_word_break_characters.encoding, Encoding::default_external)
-  end
-
-  def test_completer_word_break_characters
-    assert_equal(Reline2.completer_word_break_characters, " \t\n`><=;|&{(")
-
-    Reline2.completer_word_break_characters = "ああ"
-    assert_equal(Reline2.completer_word_break_characters, "ああ")
-    assert_equal(Reline2.completer_word_break_characters.encoding, Encoding::default_external)
-  end
-
-  def test_basic_quote_characters
-    assert_equal(Reline2.basic_quote_characters, '"\'')
-
-    Reline2.basic_quote_characters = "“"
-    assert_equal(Reline2.basic_quote_characters, "“")
-    assert_equal(Reline2.basic_quote_characters.encoding, Encoding::default_external)
-  end
-
-  def test_completer_quote_characters
-    assert_equal(Reline2.completer_quote_characters, '"\'')
-
-    Reline2.completer_quote_characters = "“"
-    assert_equal(Reline2.completer_quote_characters, "“")
-    assert_equal(Reline2.completer_quote_characters.encoding, Encoding::default_external)
-  end
-
-  def test_filename_quote_characters
-    assert_equal(Reline2.filename_quote_characters, '')
-
-    Reline2.filename_quote_characters = "\'"
-    assert_equal(Reline2.filename_quote_characters, "\'")
-    assert_equal(Reline2.filename_quote_characters.encoding, Encoding::default_external)
-  end
-
-  def test_special_prefixes
-    assert_equal(Reline2.special_prefixes, '')
-
-    Reline2.special_prefixes = "\'"
-    assert_equal(Reline2.special_prefixes, "\'")
-    assert_equal(Reline2.special_prefixes.encoding, Encoding::default_external)
-  end
-
-  def test_completion_case_fold
-    assert_equal(Reline2.completion_case_fold, nil)
-
-    Reline2.completion_case_fold = true
-    assert_equal(Reline2.completion_case_fold, true)
-
-    Reline2.completion_case_fold = "hoge"
-    assert_equal(Reline2.completion_case_fold, "hoge")
-  end
-
-  def test_completion_proc
-    assert_equal(Reline2.completion_proc, nil)
-
-    p = proc {}
-    Reline2.completion_proc = p
-    assert_equal(Reline2.completion_proc, p)
-
-    l = lambda {}
-    Reline2.completion_proc = l
-    assert_equal(Reline2.completion_proc, l)
-
-    assert_raise(ArgumentError) { Reline2.completion_proc = 42 }
-    assert_raise(ArgumentError) { Reline2.completion_proc = "hoge" }
-  end
-
-  def test_output_modifier_proc
-    assert_equal(Reline2.output_modifier_proc, nil)
-
-    p = proc {}
-    Reline2.output_modifier_proc = p
-    assert_equal(Reline2.output_modifier_proc, p)
-
-    l = lambda {}
-    Reline2.output_modifier_proc = l
-    assert_equal(Reline2.output_modifier_proc, l)
-
-    assert_raise(ArgumentError) { Reline2.output_modifier_proc = 42 }
-    assert_raise(ArgumentError) { Reline2.output_modifier_proc = "hoge" }
-  end
-
-  def test_prompt_proc
-    assert_equal(Reline2.prompt_proc, nil)
-
-    p = proc {}
-    Reline2.prompt_proc = p
-    assert_equal(Reline2.prompt_proc, p)
-
-    l = lambda {}
-    Reline2.prompt_proc = l
-    assert_equal(Reline2.prompt_proc, l)
-
-    assert_raise(ArgumentError) { Reline2.prompt_proc = 42 }
-    assert_raise(ArgumentError) { Reline2.prompt_proc = "hoge" }
-  end
-
-  def test_auto_indent_proc
-    assert_equal(Reline2.auto_indent_proc, nil)
-
-    p = proc {}
-    Reline2.auto_indent_proc = p
-    assert_equal(Reline2.auto_indent_proc, p)
-
-    l = lambda {}
-    Reline2.auto_indent_proc = l
-    assert_equal(Reline2.auto_indent_proc, l)
-
-    assert_raise(ArgumentError) { Reline2.auto_indent_proc = 42 }
-    assert_raise(ArgumentError) { Reline2.auto_indent_proc = "hoge" }
-  end
-
-  def test_pre_input_hook
-    assert_equal(Reline2.pre_input_hook, nil)
-
-    p = proc {}
-    Reline2.pre_input_hook = p
-    assert_equal(Reline2.pre_input_hook, p)
-
-    l = lambda {}
-    Reline2.pre_input_hook = l
-    assert_equal(Reline2.pre_input_hook, l)
-
-    assert_raise(ArgumentError) { Reline2.pre_input_hook = 42 }
-    assert_raise(ArgumentError) { Reline2.pre_input_hook = "hoge" }
-  end
-
-  def test_dig_perfect_match_proc
-    assert_equal(Reline2.dig_perfect_match_proc, nil)
-
-    p = proc {}
-    Reline2.dig_perfect_match_proc = p
-    assert_equal(Reline2.dig_perfect_match_proc, p)
-
-    l = lambda {}
-    Reline2.dig_perfect_match_proc = l
-    assert_equal(Reline2.dig_perfect_match_proc, l)
-
-    assert_raise(ArgumentError) { Reline2.dig_perfect_match_proc = 42 }
-    assert_raise(ArgumentError) { Reline2.dig_perfect_match_proc = "hoge" }
-  end
-end