[ruby/irb] Rename current completor to RegexpCompletor and

refactored for future extension
(https://github.com/ruby/irb/pull/707)

* Move completion implementation to completion/regexp_completor for future extension

* Remove constant CompletionProc and PerfectMatchedProc and add a class method

* Move document display logic to InputCompletor. Each completor only need to implement `completion_caididates` and `doc_namespace`

* Move display_document logic to RelineInputMethod

* Use RegexpCompletor directly. Not through class method of InputCompletor.

* RegexpCompletor extends BaseCompletor, move back definition to completion.rb

* Move display_document test to input_method test

* Stop re-initialize completor on each completion phase

* Store completor to ReadlineInputMethod's iver

https://github.com/ruby/irb/commit/1e98521483

2 files changed, 170 insertions, 156 deletions

diff --git a/test/irb/test_completion.rb b/test/irb/test_completion.rb
index 2a659818e3..2ef8938269 100644
--- a/test/irb/test_completion.rb
+++ b/test/irb/test_completion.rb
@@ -8,71 +8,83 @@ module TestIRB
   class CompletionTest < TestCase
     def setup
       # make sure require completion candidates are not cached
-      IRB::InputCompletor.class_variable_set(:@@files_from_load_path, nil)
+      IRB::BaseCompletor.class_variable_set(:@@files_from_load_path, nil)
+    end
+
+    def teardown
+      IRB.conf[:MAIN_CONTEXT] = nil
+    end
+
+    def completion_candidates(target, bind)
+      IRB::RegexpCompletor.new.completion_candidates('', target, '', bind: bind)
+    end
+
+    def doc_namespace(target, bind)
+      IRB::RegexpCompletor.new.doc_namespace('', target, '', bind: bind)
     end
 
     class MethodCompletionTest < CompletionTest
       def test_complete_string
-        assert_include(IRB::InputCompletor.retrieve_completion_data("'foo'.up", bind: binding), "'foo'.upcase")
+        assert_include(completion_candidates("'foo'.up", binding), "'foo'.upcase")
         # completing 'foo bar'.up
-        assert_include(IRB::InputCompletor.retrieve_completion_data("bar'.up", bind: binding), "bar'.upcase")
-        assert_equal("String.upcase", IRB::InputCompletor.retrieve_completion_data("'foo'.upcase", bind: binding, doc_namespace: true))
+        assert_include(completion_candidates("bar'.up", binding), "bar'.upcase")
+        assert_equal("String.upcase", doc_namespace("'foo'.upcase", binding))
       end
 
       def test_complete_regexp
-        assert_include(IRB::InputCompletor.retrieve_completion_data("/foo/.ma", bind: binding), "/foo/.match")
+        assert_include(completion_candidates("/foo/.ma", binding), "/foo/.match")
         # completing /foo bar/.ma
-        assert_include(IRB::InputCompletor.retrieve_completion_data("bar/.ma", bind: binding), "bar/.match")
-        assert_equal("Regexp.match", IRB::InputCompletor.retrieve_completion_data("/foo/.match", bind: binding, doc_namespace: true))
+        assert_include(completion_candidates("bar/.ma", binding), "bar/.match")
+        assert_equal("Regexp.match", doc_namespace("/foo/.match", binding))
       end
 
       def test_complete_array
-        assert_include(IRB::InputCompletor.retrieve_completion_data("[].an", bind: binding), "[].any?")
-        assert_equal("Array.any?", IRB::InputCompletor.retrieve_completion_data("[].any?", bind: binding, doc_namespace: true))
+        assert_include(completion_candidates("[].an", binding), "[].any?")
+        assert_equal("Array.any?", doc_namespace("[].any?", binding))
       end
 
       def test_complete_hash_and_proc
         # hash
-        assert_include(IRB::InputCompletor.retrieve_completion_data("{}.an", bind: binding), "{}.any?")
-        assert_equal(["Proc.any?", "Hash.any?"], IRB::InputCompletor.retrieve_completion_data("{}.any?", bind: binding, doc_namespace: true))
+        assert_include(completion_candidates("{}.an", binding), "{}.any?")
+        assert_equal(["Proc.any?", "Hash.any?"], doc_namespace("{}.any?", binding))
 
         # proc
-        assert_include(IRB::InputCompletor.retrieve_completion_data("{}.bin", bind: binding), "{}.binding")
-        assert_equal(["Proc.binding", "Hash.binding"], IRB::InputCompletor.retrieve_completion_data("{}.binding", bind: binding, doc_namespace: true))
+        assert_include(completion_candidates("{}.bin", binding), "{}.binding")
+        assert_equal(["Proc.binding", "Hash.binding"], doc_namespace("{}.binding", binding))
       end
 
       def test_complete_numeric
-        assert_include(IRB::InputCompletor.retrieve_completion_data("1.positi", bind: binding), "1.positive?")
-        assert_equal("Integer.positive?", IRB::InputCompletor.retrieve_completion_data("1.positive?", bind: binding, doc_namespace: true))
+        assert_include(completion_candidates("1.positi", binding), "1.positive?")
+        assert_equal("Integer.positive?", doc_namespace("1.positive?", binding))
 
-        assert_include(IRB::InputCompletor.retrieve_completion_data("1r.positi", bind: binding), "1r.positive?")
-        assert_equal("Rational.positive?", IRB::InputCompletor.retrieve_completion_data("1r.positive?", bind: binding, doc_namespace: true))
+        assert_include(completion_candidates("1r.positi", binding), "1r.positive?")
+        assert_equal("Rational.positive?", doc_namespace("1r.positive?", binding))
 
-        assert_include(IRB::InputCompletor.retrieve_completion_data("0xFFFF.positi", bind: binding), "0xFFFF.positive?")
-        assert_equal("Integer.positive?", IRB::InputCompletor.retrieve_completion_data("0xFFFF.positive?", bind: binding, doc_namespace: true))
+        assert_include(completion_candidates("0xFFFF.positi", binding), "0xFFFF.positive?")
+        assert_equal("Integer.positive?", doc_namespace("0xFFFF.positive?", binding))
 
-        assert_empty(IRB::InputCompletor.retrieve_completion_data("1i.positi", bind: binding))
+        assert_empty(completion_candidates("1i.positi", binding))
       end
 
       def test_complete_symbol
-        assert_include(IRB::InputCompletor.retrieve_completion_data(":foo.to_p", bind: binding), ":foo.to_proc")
-        assert_equal("Symbol.to_proc", IRB::InputCompletor.retrieve_completion_data(":foo.to_proc", bind: binding, doc_namespace: true))
+        assert_include(completion_candidates(":foo.to_p", binding), ":foo.to_proc")
+        assert_equal("Symbol.to_proc", doc_namespace(":foo.to_proc", binding))
       end
 
       def test_complete_class
-        assert_include(IRB::InputCompletor.retrieve_completion_data("String.ne", bind: binding), "String.new")
-        assert_equal("String.new", IRB::InputCompletor.retrieve_completion_data("String.new", bind: binding, doc_namespace: true))
+        assert_include(completion_candidates("String.ne", binding), "String.new")
+        assert_equal("String.new", doc_namespace("String.new", binding))
       end
     end
 
     class RequireComepletionTest < CompletionTest
       def test_complete_require
-        candidates = IRB::InputCompletor::CompletionProc.("'irb", "require ", "")
+        candidates = IRB::RegexpCompletor.new.completion_candidates("require ", "'irb", "", bind: binding)
         %w['irb/init 'irb/ruby-lex].each do |word|
           assert_include candidates, word
         end
         # Test cache
-        candidates = IRB::InputCompletor::CompletionProc.("'irb", "require ", "")
+        candidates = IRB::RegexpCompletor.new.completion_candidates("require ", "'irb", "", bind: binding)
         %w['irb/init 'irb/ruby-lex].each do |word|
           assert_include candidates, word
         end
@@ -84,7 +96,7 @@ module TestIRB
         test_path = Pathname.new(temp_dir)
         $LOAD_PATH << test_path
 
-        candidates = IRB::InputCompletor::CompletionProc.("'foo", "require ", "")
+        candidates = IRB::RegexpCompletor.new.completion_candidates("require ", "'foo", "", bind: binding)
         assert_include candidates, "'foo"
       ensure
         $LOAD_PATH.pop if test_path
@@ -98,7 +110,7 @@ module TestIRB
         object.define_singleton_method(:to_s) { temp_dir }
         $LOAD_PATH << object
 
-        candidates = IRB::InputCompletor::CompletionProc.("'foo", "require ", "")
+        candidates = IRB::RegexpCompletor.new.completion_candidates("require ", "'foo", "", bind: binding)
         assert_include candidates, "'foo"
       ensure
         $LOAD_PATH.pop if object
@@ -111,27 +123,27 @@ module TestIRB
         $LOAD_PATH << object
 
         assert_nothing_raised do
-          IRB::InputCompletor::CompletionProc.("'foo", "require ", "")
+          IRB::RegexpCompletor.new.completion_candidates("require ", "'foo", "", bind: binding)
         end
       ensure
         $LOAD_PATH.pop if object
       end
 
       def test_complete_require_library_name_first
-        candidates = IRB::InputCompletor::CompletionProc.("'csv", "require ", "")
+        candidates = IRB::RegexpCompletor.new.completion_candidates("require ", "'csv", "", bind: binding)
         assert_equal "'csv", candidates.first
       end
 
       def test_complete_require_relative
         candidates = Dir.chdir(__dir__ + "/../..") do
-          IRB::InputCompletor::CompletionProc.("'lib/irb", "require_relative ", "")
+          IRB::RegexpCompletor.new.completion_candidates("require_relative ", "'lib/irb", "", bind: binding)
         end
         %w['lib/irb/init 'lib/irb/ruby-lex].each do |word|
           assert_include candidates, word
         end
         # Test cache
         candidates = Dir.chdir(__dir__ + "/../..") do
-          IRB::InputCompletor::CompletionProc.("'lib/irb", "require_relative ", "")
+          IRB::RegexpCompletor.new.completion_candidates("require_relative ", "'lib/irb", "", bind: binding)
         end
         %w['lib/irb/init 'lib/irb/ruby-lex].each do |word|
           assert_include candidates, word
@@ -160,13 +172,13 @@ module TestIRB
         local_variables.clear
         instance_variables.clear
 
-        assert_include(IRB::InputCompletor.retrieve_completion_data("str_examp", bind: binding), "str_example")
-        assert_equal("String", IRB::InputCompletor.retrieve_completion_data("str_example", bind: binding, doc_namespace: true))
-        assert_equal("String.to_s", IRB::InputCompletor.retrieve_completion_data("str_example.to_s", bind: binding, doc_namespace: true))
+        assert_include(completion_candidates("str_examp", binding), "str_example")
+        assert_equal("String", doc_namespace("str_example", binding))
+        assert_equal("String.to_s", doc_namespace("str_example.to_s", binding))
 
-        assert_include(IRB::InputCompletor.retrieve_completion_data("@str_examp", bind: binding), "@str_example")
-        assert_equal("String", IRB::InputCompletor.retrieve_completion_data("@str_example", bind: binding, doc_namespace: true))
-        assert_equal("String.to_s", IRB::InputCompletor.retrieve_completion_data("@str_example.to_s", bind: binding, doc_namespace: true))
+        assert_include(completion_candidates("@str_examp", binding), "@str_example")
+        assert_equal("String", doc_namespace("@str_example", binding))
+        assert_equal("String.to_s", doc_namespace("@str_example.to_s", binding))
       end
 
       def test_complete_sort_variables
@@ -176,7 +188,7 @@ module TestIRB
         xzy_1.clear
         xzy2.clear
 
-        candidates = IRB::InputCompletor.retrieve_completion_data("xz", bind: binding, doc_namespace: false)
+        candidates = completion_candidates("xz", binding)
         assert_equal(%w[xzy xzy2 xzy_1], candidates)
       end
     end
@@ -189,102 +201,12 @@ module TestIRB
       end
 
       def test_complete_constants
-        assert_equal(["Foo"], IRB::InputCompletor.retrieve_completion_data("Fo", bind: binding))
-        assert_equal(["Foo::B1", "Foo::B2", "Foo::B3"], IRB::InputCompletor.retrieve_completion_data("Foo::B", bind: binding))
-        assert_equal(["Foo::B1.positive?"], IRB::InputCompletor.retrieve_completion_data("Foo::B1.pos", bind: binding))
-
-        assert_equal(["::Forwardable"], IRB::InputCompletor.retrieve_completion_data("::Fo", bind: binding))
-        assert_equal("Forwardable", IRB::InputCompletor.retrieve_completion_data("::Forwardable", bind: binding, doc_namespace: true))
-      end
-    end
-
-    class PerfectMatchingTest < CompletionTest
-      def setup
-        # trigger PerfectMatchedProc to set up RDocRIDriver constant
-        IRB::InputCompletor::PerfectMatchedProc.("foo", bind: binding)
-
-        @original_use_stdout = IRB::InputCompletor::RDocRIDriver.use_stdout
-        # force the driver to use stdout so it doesn't start a pager and interrupt tests
-        IRB::InputCompletor::RDocRIDriver.use_stdout = true
-      end
-
-      def teardown
-        IRB::InputCompletor::RDocRIDriver.use_stdout = @original_use_stdout
-      end
-
-      def test_perfectly_matched_namespace_triggers_document_display
-        omit unless has_rdoc_content?
-
-        out, err = capture_output do
-          IRB::InputCompletor::PerfectMatchedProc.("String", bind: binding)
-        end
-
-        assert_empty(err)
-
-        assert_include(out, " S\bSt\btr\bri\bin\bng\bg")
-      end
-
-      def test_perfectly_matched_multiple_namespaces_triggers_document_display
-        result = nil
-        out, err = capture_output do
-          result = IRB::InputCompletor::PerfectMatchedProc.("{}.nil?", bind: binding)
-        end
-
-        assert_empty(err)
-
-        # check if there're rdoc contents (e.g. CI doesn't generate them)
-        if has_rdoc_content?
-          # if there's rdoc content, we can verify by checking stdout
-          # rdoc generates control characters for formatting method names
-          assert_include(out, "P\bPr\bro\boc\bc.\b.n\bni\bil\bl?\b?") # Proc.nil?
-          assert_include(out, "H\bHa\bas\bsh\bh.\b.n\bni\bil\bl?\b?") # Hash.nil?
-        else
-          # this is a hacky way to verify the rdoc rendering code path because CI doesn't have rdoc content
-          # if there are multiple namespaces to be rendered, PerfectMatchedProc renders the result with a document
-          # which always returns the bytes rendered, even if it's 0
-          assert_equal(0, result)
-        end
-      end
-
-      def test_not_matched_namespace_triggers_nothing
-        result = nil
-        out, err = capture_output do
-          result = IRB::InputCompletor::PerfectMatchedProc.("Stri", bind: binding)
-        end
-
-        assert_empty(err)
-        assert_empty(out)
-        assert_nil(result)
-      end
-
-      def test_perfect_matching_stops_without_rdoc
-        result = nil
-
-        out, err = capture_output do
-          without_rdoc do
-            result = IRB::InputCompletor::PerfectMatchedProc.("String", bind: binding)
-          end
-        end
-
-        assert_empty(err)
-        assert_not_match(/from ruby core/, out)
-        assert_nil(result)
-      end
-
-      def test_perfect_matching_handles_nil_namespace
-        out, err = capture_output do
-          # symbol literal has `nil` doc namespace so it's a good test subject
-          assert_nil(IRB::InputCompletor::PerfectMatchedProc.(":aiueo", bind: binding))
-        end
-
-        assert_empty(err)
-        assert_empty(out)
-      end
-
-      private
+        assert_equal(["Foo"], completion_candidates("Fo", binding))
+        assert_equal(["Foo::B1", "Foo::B2", "Foo::B3"], completion_candidates("Foo::B", binding))
+        assert_equal(["Foo::B1.positive?"], completion_candidates("Foo::B1.pos", binding))
 
-      def has_rdoc_content?
-        File.exist?(RDoc::RI::Paths::BASE)
+        assert_equal(["::Forwardable"], completion_candidates("::Fo", binding))
+        assert_equal("Forwardable", doc_namespace("::Forwardable", binding))
       end
     end
 
@@ -294,34 +216,34 @@ module TestIRB
       rescue
       end
       symbols += [:aiueo, :"aiu eo"]
-      candidates = IRB::InputCompletor.retrieve_completion_data(":a", bind: binding)
+      candidates = completion_candidates(":a", binding)
       assert_include(candidates, ":aiueo")
       assert_not_include(candidates, ":aiu eo")
-      assert_empty(IRB::InputCompletor.retrieve_completion_data(":irb_unknown_symbol_abcdefg", bind: binding))
+      assert_empty(completion_candidates(":irb_unknown_symbol_abcdefg", binding))
       # Do not complete empty symbol for performance reason
-      assert_empty(IRB::InputCompletor.retrieve_completion_data(":", bind: binding))
+      assert_empty(completion_candidates(":", binding))
     end
 
     def test_complete_invalid_three_colons
-      assert_empty(IRB::InputCompletor.retrieve_completion_data(":::A", bind: binding))
-      assert_empty(IRB::InputCompletor.retrieve_completion_data(":::", bind: binding))
+      assert_empty(completion_candidates(":::A", binding))
+      assert_empty(completion_candidates(":::", binding))
     end
 
     def test_complete_absolute_constants_with_special_characters
-      assert_empty(IRB::InputCompletor.retrieve_completion_data("::A:", bind: binding))
-      assert_empty(IRB::InputCompletor.retrieve_completion_data("::A.", bind: binding))
-      assert_empty(IRB::InputCompletor.retrieve_completion_data("::A(", bind: binding))
-      assert_empty(IRB::InputCompletor.retrieve_completion_data("::A)", bind: binding))
-      assert_empty(IRB::InputCompletor.retrieve_completion_data("::A[", bind: binding))
+      assert_empty(completion_candidates("::A:", binding))
+      assert_empty(completion_candidates("::A.", binding))
+      assert_empty(completion_candidates("::A(", binding))
+      assert_empty(completion_candidates("::A)", binding))
+      assert_empty(completion_candidates("::A[", binding))
     end
 
     def test_complete_reserved_words
-      candidates = IRB::InputCompletor.retrieve_completion_data("de", bind: binding)
+      candidates = completion_candidates("de", binding)
       %w[def defined?].each do |word|
         assert_include candidates, word
       end
 
-      candidates = IRB::InputCompletor.retrieve_completion_data("__", bind: binding)
+      candidates = completion_candidates("__", binding)
       %w[__ENCODING__ __LINE__ __FILE__].each do |word|
         assert_include candidates, word
       end
@@ -342,11 +264,11 @@ module TestIRB
       }
       bind = obj.instance_exec { binding }
 
-      assert_include(IRB::InputCompletor.retrieve_completion_data("public_hog", bind: bind), "public_hoge")
-      assert_include(IRB::InputCompletor.retrieve_completion_data("public_hoge", bind: bind, doc_namespace: true), "public_hoge")
+      assert_include(completion_candidates("public_hog", bind), "public_hoge")
+      assert_include(doc_namespace("public_hoge", bind), "public_hoge")
 
-      assert_include(IRB::InputCompletor.retrieve_completion_data("private_hog", bind: bind), "private_hoge")
-      assert_include(IRB::InputCompletor.retrieve_completion_data("private_hoge", bind: bind, doc_namespace: true), "private_hoge")
+      assert_include(completion_candidates("private_hog", bind), "private_hoge")
+      assert_include(doc_namespace("private_hoge", bind), "private_hoge")
     end
   end
 end
diff --git a/test/irb/test_input_method.rb b/test/irb/test_input_method.rb
index b516be5e3c..2d8cfadcf5 100644
--- a/test/irb/test_input_method.rb
+++ b/test/irb/test_input_method.rb
@@ -1,11 +1,11 @@
 # frozen_string_literal: false
 
 require "irb"
-
+require "rdoc"
 require_relative "helper"
 
 module TestIRB
-  class RelineInputMethodTest < TestCase
+  class InputMethodTest < TestCase
     def setup
       @conf_backup = IRB.conf.dup
       IRB.conf[:LC_MESSAGES] = IRB::Locale.new
@@ -18,15 +18,19 @@ module TestIRB
       # Reset Reline configuration overrided by RelineInputMethod.
       Reline.instance_variable_set(:@core, nil)
     end
+  end
 
+  class RelineInputMethodTest < InputMethodTest
     def test_initialization
+      Reline.completion_proc = nil
+      Reline.dig_perfect_match_proc = nil
       IRB::RelineInputMethod.new
 
       assert_nil Reline.completion_append_character
       assert_equal '', Reline.completer_quote_characters
-      assert_equal IRB::InputCompletor::BASIC_WORD_BREAK_CHARACTERS, Reline.basic_word_break_characters
-      assert_equal IRB::InputCompletor::CompletionProc, Reline.completion_proc
-      assert_equal IRB::InputCompletor::PerfectMatchedProc, Reline.dig_perfect_match_proc
+      assert_equal IRB::InputMethod::BASIC_WORD_BREAK_CHARACTERS, Reline.basic_word_break_characters
+      assert_not_nil Reline.completion_proc
+      assert_not_nil Reline.dig_perfect_match_proc
     end
 
     def test_initialization_without_use_autocomplete
@@ -54,7 +58,7 @@ module TestIRB
       IRB::RelineInputMethod.new
 
       assert Reline.autocompletion
-      assert_equal IRB::RelineInputMethod::SHOW_DOC_DIALOG, Reline.dialog_proc(:show_doc).dialog_proc
+      assert_not_equal empty_proc, Reline.dialog_proc(:show_doc).dialog_proc
     ensure
       Reline.add_dialog_proc(:show_doc, original_show_doc_proc, Reline::DEFAULT_DIALOG_CONTEXT)
     end
@@ -77,5 +81,93 @@ module TestIRB
       Reline.add_dialog_proc(:show_doc, original_show_doc_proc, Reline::DEFAULT_DIALOG_CONTEXT)
     end
   end
+
+  class DisplayDocumentTest < InputMethodTest
+    def setup
+      super
+      @driver = RDoc::RI::Driver.new(use_stdout: true)
+    end
+
+    def display_document(target, bind)
+      input_method = IRB::RelineInputMethod.new
+      input_method.instance_variable_set(:@completion_params, [target, '', '', bind])
+      input_method.display_document(target, driver: @driver)
+    end
+
+    def test_perfectly_matched_namespace_triggers_document_display
+      omit unless has_rdoc_content?
+
+      out, err = capture_output do
+        display_document("String", binding)
+      end
+
+      assert_empty(err)
+
+      assert_include(out, " S\bSt\btr\bri\bin\bng\bg")
+    end
+
+    def test_perfectly_matched_multiple_namespaces_triggers_document_display
+      result = nil
+      out, err = capture_output do
+        result = display_document("{}.nil?", binding)
+      end
+
+      assert_empty(err)
+
+      # check if there're rdoc contents (e.g. CI doesn't generate them)
+      if has_rdoc_content?
+        # if there's rdoc content, we can verify by checking stdout
+        # rdoc generates control characters for formatting method names
+        assert_include(out, "P\bPr\bro\boc\bc.\b.n\bni\bil\bl?\b?") # Proc.nil?
+        assert_include(out, "H\bHa\bas\bsh\bh.\b.n\bni\bil\bl?\b?") # Hash.nil?
+      else
+        # this is a hacky way to verify the rdoc rendering code path because CI doesn't have rdoc content
+        # if there are multiple namespaces to be rendered, PerfectMatchedProc renders the result with a document
+        # which always returns the bytes rendered, even if it's 0
+        assert_equal(0, result)
+      end
+    end
+
+    def test_not_matched_namespace_triggers_nothing
+      result = nil
+      out, err = capture_output do
+        result = display_document("Stri", binding)
+      end
+
+      assert_empty(err)
+      assert_empty(out)
+      assert_nil(result)
+    end
+
+    def test_perfect_matching_stops_without_rdoc
+      result = nil
+
+      out, err = capture_output do
+        without_rdoc do
+          result = display_document("String", binding)
+        end
+      end
+
+      assert_empty(err)
+      assert_not_match(/from ruby core/, out)
+      assert_nil(result)
+    end
+
+    def test_perfect_matching_handles_nil_namespace
+      out, err = capture_output do
+        # symbol literal has `nil` doc namespace so it's a good test subject
+        assert_nil(display_document(":aiueo", binding))
+      end
+
+      assert_empty(err)
+      assert_empty(out)
+    end
+
+    private
+
+    def has_rdoc_content?
+      File.exist?(RDoc::RI::Paths::BASE)
+    end
+  end
 end