[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, 206 insertions, 181 deletions

diff --git a/lib/irb/completion.rb b/lib/irb/completion.rb
index a143d1b3e1..26215f6fe1 100644
--- a/lib/irb/completion.rb
+++ b/lib/irb/completion.rb
@@ -8,55 +8,14 @@
 require_relative 'ruby-lex'
 
 module IRB
-  module InputCompletor # :nodoc:
-    using Module.new {
-      refine ::Binding do
-        def eval_methods
-          ::Kernel.instance_method(:methods).bind(eval("self")).call
-        end
-
-        def eval_private_methods
-          ::Kernel.instance_method(:private_methods).bind(eval("self")).call
-        end
-
-        def eval_instance_variables
-          ::Kernel.instance_method(:instance_variables).bind(eval("self")).call
-        end
-
-        def eval_global_variables
-          ::Kernel.instance_method(:global_variables).bind(eval("self")).call
-        end
-
-        def eval_class_constants
-          ::Module.instance_method(:constants).bind(eval("self.class")).call
-        end
-      end
-    }
-
-    # Set of reserved words used by Ruby, you should not use these for
-    # constants or variables
-    ReservedWords = %w[
-      __ENCODING__ __LINE__ __FILE__
-      BEGIN END
-      alias and
-      begin break
-      case class
-      def defined? do
-      else elsif end ensure
-      false for
-      if in
-      module
-      next nil not
-      or
-      redo rescue retry return
-      self super
-      then true
-      undef unless until
-      when while
-      yield
-    ]
+  class BaseCompletor # :nodoc:
+    def completion_candidates(preposing, target, postposing, bind:)
+      raise NotImplementedError
+    end
 
-    BASIC_WORD_BREAK_CHARACTERS = " \t\n`><=;|&{("
+    def doc_namespace(preposing, matched, postposing, bind:)
+      raise NotImplementedError
+    end
 
     GEM_PATHS =
       if defined?(Gem::Specification)
@@ -73,7 +32,7 @@ module IRB
         []
       end.freeze
 
-    def self.retrieve_gem_and_system_load_path
+    def retrieve_gem_and_system_load_path
       candidates = (GEM_PATHS | $LOAD_PATH)
       candidates.map do |p|
         if p.respond_to?(:to_path)
@@ -84,8 +43,8 @@ module IRB
       end.compact.sort
     end
 
-    def self.retrieve_files_to_require_from_load_path
-      @@files_from_load_path ||=
+    def retrieve_files_to_require_from_load_path
+      @files_from_load_path ||=
         (
           shortest = []
           rest = retrieve_gem_and_system_load_path.each_with_object([]) { |path, result|
@@ -103,13 +62,62 @@ module IRB
         )
     end
 
-    def self.retrieve_files_to_require_relative_from_current_dir
-      @@files_from_current_dir ||= Dir.glob("**/*.{rb,#{RbConfig::CONFIG['DLEXT']}}", base: '.').map { |path|
+    def retrieve_files_to_require_relative_from_current_dir
+      @files_from_current_dir ||= Dir.glob("**/*.{rb,#{RbConfig::CONFIG['DLEXT']}}", base: '.').map { |path|
         path.sub(/\.(rb|#{RbConfig::CONFIG['DLEXT']})\z/, '')
       }
     end
+  end
 
-    CompletionRequireProc = lambda { |target, preposing = nil, postposing = nil|
+  class RegexpCompletor < BaseCompletor # :nodoc:
+    using Module.new {
+      refine ::Binding do
+        def eval_methods
+          ::Kernel.instance_method(:methods).bind(eval("self")).call
+        end
+
+        def eval_private_methods
+          ::Kernel.instance_method(:private_methods).bind(eval("self")).call
+        end
+
+        def eval_instance_variables
+          ::Kernel.instance_method(:instance_variables).bind(eval("self")).call
+        end
+
+        def eval_global_variables
+          ::Kernel.instance_method(:global_variables).bind(eval("self")).call
+        end
+
+        def eval_class_constants
+          ::Module.instance_method(:constants).bind(eval("self.class")).call
+        end
+      end
+    }
+
+    # Set of reserved words used by Ruby, you should not use these for
+    # constants or variables
+    ReservedWords = %w[
+      __ENCODING__ __LINE__ __FILE__
+      BEGIN END
+      alias and
+      begin break
+      case class
+      def defined? do
+      else elsif end ensure
+      false for
+      if in
+      module
+      next nil not
+      or
+      redo rescue retry return
+      self super
+      then true
+      undef unless until
+      when while
+      yield
+    ]
+
+    def complete_require_path(target, preposing, postposing)
       if target =~ /\A(['"])([^'"]+)\Z/
         quote = $1
         actual_target = $2
@@ -142,21 +150,21 @@ module IRB
         end
       end
       result
-    }
+    end
 
-    CompletionProc = lambda { |target, preposing = nil, postposing = nil|
+    def completion_candidates(preposing, target, postposing, bind:)
       if preposing && postposing
-        result = CompletionRequireProc.(target, preposing, postposing)
-        unless result
-          result = retrieve_completion_data(target).compact.map{ |i| i.encode(Encoding.default_external) }
-        end
-        result
-      else
-        retrieve_completion_data(target).compact.map{ |i| i.encode(Encoding.default_external) }
+        result = complete_require_path(target, preposing, postposing)
+        return result if result
       end
-    }
+      retrieve_completion_data(target, bind: bind, doc_namespace: false).compact.map{ |i| i.encode(Encoding.default_external) }
+    end
 
-    def self.retrieve_completion_data(input, bind: IRB.conf[:MAIN_CONTEXT].workspace.binding, doc_namespace: false)
+    def doc_namespace(_preposing, matched, _postposing, bind:)
+      retrieve_completion_data(matched, bind: bind, doc_namespace: true)
+    end
+
+    def retrieve_completion_data(input, bind:, doc_namespace:)
       case input
       # this regexp only matches the closing character because of irb's Reline.completer_quote_characters setting
       # details are described in: https://github.com/ruby/irb/pull/523
@@ -394,44 +402,10 @@ module IRB
       end
     end
 
-    PerfectMatchedProc = ->(matched, bind: IRB.conf[:MAIN_CONTEXT].workspace.binding) {
-      begin
-        require 'rdoc'
-      rescue LoadError
-        return
-      end
-
-      RDocRIDriver ||= RDoc::RI::Driver.new
-
-      if matched =~ /\A(?:::)?RubyVM/ and not ENV['RUBY_YES_I_AM_NOT_A_NORMAL_USER']
-        IRB.__send__(:easter_egg)
-        return
-      end
-
-      namespace = retrieve_completion_data(matched, bind: bind, doc_namespace: true)
-      return unless namespace
-
-      if namespace.is_a?(Array)
-        out = RDoc::Markup::Document.new
-        namespace.each do |m|
-          begin
-            RDocRIDriver.add_method(out, m)
-          rescue RDoc::RI::Driver::NotFoundError
-          end
-        end
-        RDocRIDriver.display(out)
-      else
-        begin
-          RDocRIDriver.display_names([namespace])
-        rescue RDoc::RI::Driver::NotFoundError
-        end
-      end
-    }
-
     # Set of available operators in Ruby
     Operators = %w[% & * ** + - / < << <= <=> == === =~ > >= >> [] []= ^ ! != !~]
 
-    def self.select_message(receiver, message, candidates, sep = ".")
+    def select_message(receiver, message, candidates, sep = ".")
       candidates.grep(/^#{Regexp.quote(message)}/).collect do |e|
         case e
         when /^[a-zA-Z_]/
diff --git a/lib/irb/input-method.rb b/lib/irb/input-method.rb
index bd7d4fede4..454b6db00b 100644
--- a/lib/irb/input-method.rb
+++ b/lib/irb/input-method.rb
@@ -11,6 +11,8 @@ require 'reline'
 
 module IRB
   class InputMethod
+    BASIC_WORD_BREAK_CHARACTERS = " \t\n`><=;|&{("
+
     # The irb prompt associated with this input method
     attr_accessor :prompt
 
@@ -179,12 +181,16 @@ module IRB
       super
 
       @eof = false
+      @completor = RegexpCompletor.new
 
       if Readline.respond_to?("basic_word_break_characters=")
-        Readline.basic_word_break_characters = IRB::InputCompletor::BASIC_WORD_BREAK_CHARACTERS
+        Readline.basic_word_break_characters = BASIC_WORD_BREAK_CHARACTERS
       end
       Readline.completion_append_character = nil
-      Readline.completion_proc = IRB::InputCompletor::CompletionProc
+      Readline.completion_proc = ->(target) {
+        bind = IRB.conf[:MAIN_CONTEXT].workspace.binding
+        @completor.completion_candidates('', target, '', bind: bind)
+      }
     end
 
     # Reads the next line from this input method.
@@ -230,11 +236,16 @@ module IRB
       super
 
       @eof = false
+      @completor = RegexpCompletor.new
 
-      Reline.basic_word_break_characters = IRB::InputCompletor::BASIC_WORD_BREAK_CHARACTERS
+      Reline.basic_word_break_characters = BASIC_WORD_BREAK_CHARACTERS
       Reline.completion_append_character = nil
       Reline.completer_quote_characters = ''
-      Reline.completion_proc = IRB::InputCompletor::CompletionProc
+      Reline.completion_proc = ->(target, preposing, postposing) {
+        bind = IRB.conf[:MAIN_CONTEXT].workspace.binding
+        @completion_params = [preposing, target, postposing, bind]
+        @completor.completion_candidates(preposing, target, postposing, bind: bind)
+      }
       Reline.output_modifier_proc =
         if IRB.conf[:USE_COLORIZE]
           proc do |output, complete: |
@@ -247,13 +258,13 @@ module IRB
             Reline::Unicode.escape_for_print(output)
           end
         end
-      Reline.dig_perfect_match_proc = IRB::InputCompletor::PerfectMatchedProc
+      Reline.dig_perfect_match_proc = ->(matched) { display_document(matched) }
       Reline.autocompletion = IRB.conf[:USE_AUTOCOMPLETE]
 
       if IRB.conf[:USE_AUTOCOMPLETE]
         begin
           require 'rdoc'
-          Reline.add_dialog_proc(:show_doc, SHOW_DOC_DIALOG, Reline::DEFAULT_DIALOG_CONTEXT)
+          Reline.add_dialog_proc(:show_doc, show_doc_dialog_proc, Reline::DEFAULT_DIALOG_CONTEXT)
         rescue LoadError
         end
       end
@@ -271,100 +282,140 @@ module IRB
       @auto_indent_proc = block
     end
 
-    SHOW_DOC_DIALOG = ->() {
-      dialog.trap_key = nil
-      alt_d = [
-        [Reline::Key.new(nil, 0xE4, true)], # Normal Alt+d.
-        [27, 100], # Normal Alt+d when convert-meta isn't used.
-        [195, 164], # The "ä" that appears when Alt+d is pressed on xterm.
-        [226, 136, 130] # The "∂" that appears when Alt+d in pressed on iTerm2.
-      ]
+    def show_doc_dialog_proc
+      doc_namespace = ->(matched) {
+        preposing, _target, postposing, bind = @completion_params
+        @completor.doc_namespace(preposing, matched, postposing, bind: bind)
+      }
+      ->() {
+        dialog.trap_key = nil
+        alt_d = [
+          [Reline::Key.new(nil, 0xE4, true)], # Normal Alt+d.
+          [27, 100], # Normal Alt+d when convert-meta isn't used.
+          [195, 164], # The "ä" that appears when Alt+d is pressed on xterm.
+          [226, 136, 130] # The "∂" that appears when Alt+d in pressed on iTerm2.
+        ]
+
+        if just_cursor_moving and completion_journey_data.nil?
+          return nil
+        end
+        cursor_pos_to_render, result, pointer, autocomplete_dialog = context.pop(4)
+        return nil if result.nil? or pointer.nil? or pointer < 0
 
-      if just_cursor_moving and completion_journey_data.nil?
-        return nil
-      end
-      cursor_pos_to_render, result, pointer, autocomplete_dialog = context.pop(4)
-      return nil if result.nil? or pointer.nil? or pointer < 0
-      name = result[pointer]
-      name = IRB::InputCompletor.retrieve_completion_data(name, doc_namespace: true)
+        name = doc_namespace.call(result[pointer])
 
-      options = {}
-      options[:extra_doc_dirs] = IRB.conf[:EXTRA_DOC_DIRS] unless IRB.conf[:EXTRA_DOC_DIRS].empty?
-      driver = RDoc::RI::Driver.new(options)
+        options = {}
+        options[:extra_doc_dirs] = IRB.conf[:EXTRA_DOC_DIRS] unless IRB.conf[:EXTRA_DOC_DIRS].empty?
+        driver = RDoc::RI::Driver.new(options)
 
-      if key.match?(dialog.name)
-        begin
-          driver.display_names([name])
-        rescue RDoc::RI::Driver::NotFoundError
+        if key.match?(dialog.name)
+          begin
+            driver.display_names([name])
+          rescue RDoc::RI::Driver::NotFoundError
+          end
         end
-      end
 
-      begin
-        name = driver.expand_name(name)
-      rescue RDoc::RI::Driver::NotFoundError
-        return nil
-      rescue
-        return nil # unknown error
-      end
-      doc = nil
-      used_for_class = false
-      if not name =~ /#|\./
-        found, klasses, includes, extends = driver.classes_and_includes_and_extends_for(name)
-        if not found.empty?
-          doc = driver.class_document(name, found, klasses, includes, extends)
-          used_for_class = true
-        end
-      end
-      unless used_for_class
-        doc = RDoc::Markup::Document.new
         begin
-          driver.add_method(doc, name)
+          name = driver.expand_name(name)
         rescue RDoc::RI::Driver::NotFoundError
-          doc = nil
+          return nil
         rescue
           return nil # unknown error
         end
-      end
-      return nil if doc.nil?
-      width = 40
-
-      right_x = cursor_pos_to_render.x + autocomplete_dialog.width
-      if right_x + width > screen_width
-        right_width = screen_width - (right_x + 1)
-        left_x = autocomplete_dialog.column - width
-        left_x = 0 if left_x < 0
-        left_width = width > autocomplete_dialog.column ? autocomplete_dialog.column : width
-        if right_width.positive? and left_width.positive?
-          if right_width >= left_width
+        doc = nil
+        used_for_class = false
+        if not name =~ /#|\./
+          found, klasses, includes, extends = driver.classes_and_includes_and_extends_for(name)
+          if not found.empty?
+            doc = driver.class_document(name, found, klasses, includes, extends)
+            used_for_class = true
+          end
+        end
+        unless used_for_class
+          doc = RDoc::Markup::Document.new
+          begin
+            driver.add_method(doc, name)
+          rescue RDoc::RI::Driver::NotFoundError
+            doc = nil
+          rescue
+            return nil # unknown error
+          end
+        end
+        return nil if doc.nil?
+        width = 40
+
+        right_x = cursor_pos_to_render.x + autocomplete_dialog.width
+        if right_x + width > screen_width
+          right_width = screen_width - (right_x + 1)
+          left_x = autocomplete_dialog.column - width
+          left_x = 0 if left_x < 0
+          left_width = width > autocomplete_dialog.column ? autocomplete_dialog.column : width
+          if right_width.positive? and left_width.positive?
+            if right_width >= left_width
+              width = right_width
+              x = right_x
+            else
+              width = left_width
+              x = left_x
+            end
+          elsif right_width.positive? and left_width <= 0
             width = right_width
             x = right_x
-          else
+          elsif right_width <= 0 and left_width.positive?
             width = left_width
             x = left_x
+          else # Both are negative width.
+            return nil
           end
-        elsif right_width.positive? and left_width <= 0
-          width = right_width
+        else
           x = right_x
-        elsif right_width <= 0 and left_width.positive?
-          width = left_width
-          x = left_x
-        else # Both are negative width.
-          return nil
         end
+        formatter = RDoc::Markup::ToAnsi.new
+        formatter.width = width
+        dialog.trap_key = alt_d
+        mod_key = RUBY_PLATFORM.match?(/darwin/) ? "Option" : "Alt"
+        message = "Press #{mod_key}+d to read the full document"
+        contents = [message] + doc.accept(formatter).split("\n")
+        contents = contents.take(preferred_dialog_height)
+
+        y = cursor_pos_to_render.y
+        Reline::DialogRenderInfo.new(pos: Reline::CursorPos.new(x, y), contents: contents, width: width, bg_color: '49')
+      }
+    end
+
+    def display_document(matched, driver: nil)
+      begin
+        require 'rdoc'
+      rescue LoadError
+        return
+      end
+
+      if matched =~ /\A(?:::)?RubyVM/ and not ENV['RUBY_YES_I_AM_NOT_A_NORMAL_USER']
+        IRB.__send__(:easter_egg)
+        return
+      end
+
+      _target, preposing, postposing, bind = @completion_params
+      namespace = @completor.doc_namespace(preposing, matched, postposing, bind: bind)
+      return unless namespace
+
+      driver ||= RDoc::RI::Driver.new
+      if namespace.is_a?(Array)
+        out = RDoc::Markup::Document.new
+        namespace.each do |m|
+          begin
+            driver.add_method(out, m)
+          rescue RDoc::RI::Driver::NotFoundError
+          end
+        end
+        driver.display(out)
       else
-        x = right_x
+        begin
+          driver.display_names([namespace])
+        rescue RDoc::RI::Driver::NotFoundError
+        end
       end
-      formatter = RDoc::Markup::ToAnsi.new
-      formatter.width = width
-      dialog.trap_key = alt_d
-      mod_key = RUBY_PLATFORM.match?(/darwin/) ? "Option" : "Alt"
-      message = "Press #{mod_key}+d to read the full document"
-      contents = [message] + doc.accept(formatter).split("\n")
-      contents = contents.take(preferred_dialog_height)
-
-      y = cursor_pos_to_render.y
-      Reline::DialogRenderInfo.new(pos: Reline::CursorPos.new(x, y), contents: contents, width: width, bg_color: '49')
-    }
+    end
 
     # Reads the next line from this input method.
     #