Use filename for correct require_relative path completion

Author: tompng

README.md

@@ -32,7 +32,7 @@ Now you can get completion candidates.
 ```ruby
 array = [1, 2, 3]
 class String; def upupup; end; end
-result = ReplCompletion.analyze('array.map do str = _1.chr; str.up', binding)
+result = ReplCompletion.analyze('array.map do str = _1.chr; str.up', binding: binding)
 result.completion_candidates #=> ["case", "case!", "to", "upup"]
 result.doc_namespace('case') #=> "String#upcase"
 ```
@@ -54,7 +54,7 @@ ReplCompletion.rbs_load_started?
 ReplCompletion.rbs_loaded?
 ReplCompletion.rbs_load_error
 ReplCompletion.last_completion_error
-ReplCompletion.analyze(code_to_complete, binding)
+ReplCompletion.analyze(code_to_complete, binding: binding)
 ```
 
 ## License

lib/repl_completion.rb

@@ -28,10 +28,10 @@ def preload_rbs
       Types.preload_rbs_builder
     end
 
-    def analyze(code, binding)
+    def analyze(code, binding:, filename: nil)
       verbose, $VERBOSE = $VERBOSE, nil
       result = analyze_code(code, binding)
-      Result.new(result, binding) if result
+      Result.new(result, binding, filename) if result
     rescue Exception => e
       handle_exception(e)
       nil

lib/repl_completion/require_paths.rb

@@ -19,11 +19,11 @@ def require_completions(target_path)
         end
       end
 
-      def require_relative_completions(target_path, binding)
-        current_filepath = binding.source_location[0]
+      def require_relative_completions(target_path, source_file)
+        source_dir = source_file ? File.dirname(source_file) : Dir.pwd
         *dir, target = target_path.split('/', -1)
         target ||= ''
-        base_dir = File.absolute_path(File.join(File.dirname(current_filepath), *dir))
+        base_dir = File.absolute_path(File.join(source_dir, *dir))
         paths = with_cache [:requireable_paths, base_dir] do
           requireable_paths(base_dir)
         end

lib/repl_completion/result.rb

@@ -26,9 +26,10 @@ def defined? do
       yield
     ]
 
-    def initialize(analyze_result, binding)
+    def initialize(analyze_result, binding, source_file)
       @analyze_result = analyze_result
       @binding = binding
+      @source_file = source_file
     end
 
     def completion_candidates
@@ -37,7 +38,7 @@ def completion_candidates
       in [:require, name]
         RequirePaths.require_completions(name)
       in [:require_relative, name]
-        RequirePaths.require_relative_completions(name, @binding)
+        RequirePaths.require_relative_completions(name, @source_file)
       in [:call_or_const, name, type, self_call]
         ((self_call ? type.all_methods : type.methods).map(&:to_s) - HIDDEN_METHODS) | type.constants
       in [:const, name, type, scope]

sig/repl_completion.rbs

@@ -6,7 +6,7 @@ module ReplCompletion
     def doc_namespace: (String) -> String?
   end
 
-  def self.analyze: (String, Binding) -> Result?
+  def self.analyze: (String, binding: Binding, ?filename: String?) -> Result?
 
   def self.rbs_load_error: () -> Exception?
   def self.last_completion_error: () -> Exception?

test/repl_completion/test_repl_completion.rb

@@ -15,21 +15,27 @@ def empty_binding
 
     TARGET_REGEXP = /(@@|@|\$)?[a-zA-Z_]*[!?=]?$/
 
-    def assert_completion(code, binding: empty_binding, include: nil, exclude: nil)
+    def assert_completion(code, binding: empty_binding, filename: nil, include: nil, exclude: nil)
       raise ArgumentError if include.nil? && exclude.nil?
-      candidates = ReplCompletion.analyze(code, binding).completion_candidates
+      candidates = ReplCompletion.analyze(code, binding: binding, filename: filename).completion_candidates
       assert ([*include] - candidates).empty?, "Expected #{candidates} to include #{include}" if include
       assert (candidates & [*exclude]).empty?, "Expected #{candidates} not to include #{exclude}" if exclude
     end
 
     def assert_doc_namespace(code, namespace, binding: empty_binding)
-      assert_equal namespace, ReplCompletion.analyze(code, binding).doc_namespace('')
+      assert_equal namespace, ReplCompletion.analyze(code, binding: binding).doc_namespace('')
     end
 
     def test_require
       assert_completion("require '", include: 'set')
       assert_completion("require 's", include: 'et')
-      assert_completion("require_relative 'test_", include: 'repl_completion')
+      assert_completion("require_relative 'test_", filename: __FILE__, include: 'repl_completion')
+      assert_completion("require_relative '../repl_", filename: __FILE__, include: 'completion/test_repl_completion')
+      Dir.chdir File.join(__dir__, '..') do
+        assert_completion("require_relative 'repl_", filename: nil, include: 'completion/test_repl_completion')
+        assert_completion("require_relative 'repl_", filename: '(irb)', include: 'completion/test_repl_completion')
+      end
+
       # Incomplete double quote string is InterpolatedStringNode
       assert_completion('require "', include: 'set')
       assert_completion('require "s', include: 'et')
@@ -155,12 +161,12 @@ def test_deprecated_const_without_warning
     end
 
     def test_sig_dir
-      assert_doc_namespace('ReplCompletion.analyze(code, binding).completion_candidates.__id__', 'Array#__id__')
-      assert_doc_namespace('ReplCompletion.analyze(code, binding).doc_namespace.__id__', 'String#__id__')
+      assert_doc_namespace('ReplCompletion.analyze(code, binding: binding).completion_candidates.__id__', 'Array#__id__')
+      assert_doc_namespace('ReplCompletion.analyze(code, binding: binding).doc_namespace.__id__', 'String#__id__')
     end
 
     def test_none
-      result = ReplCompletion.analyze('()', binding)
+      result = ReplCompletion.analyze('()', binding: binding)
       assert_nil result
     end
 
@@ -187,15 +193,15 @@ def with_failing_method(klass, method_name, message)
 
     def test_analyze_error
       with_failing_method(ReplCompletion.singleton_class, :analyze_code, 'error_in_analyze_code') do
-        assert_nil ReplCompletion.analyze '1.', binding
+        assert_nil ReplCompletion.analyze('1.', binding: binding)
       end
       assert_equal 'error_in_analyze_code', ReplCompletion.last_completion_error&.message
     ensure
       ReplCompletion.instance_variable_set(:@last_completion_error, nil)
     end
 
     def test_completion_candidates_error
-      result = ReplCompletion.analyze '1.', binding
+      result = ReplCompletion.analyze '1.', binding: binding
       with_failing_method(ReplCompletion::Types::InstanceType, :methods, 'error_in_methods') do
         assert_equal [], result.completion_candidates
       end
@@ -205,7 +211,7 @@ def test_completion_candidates_error
     end
 
     def test_doc_namespace_error
-      result = ReplCompletion.analyze '1.', binding
+      result = ReplCompletion.analyze '1.', binding: binding
       with_failing_method(ReplCompletion::Result, :method_doc, 'error_in_method_doc') do
         assert_nil result.doc_namespace('abs')
       end

test/repl_completion/test_require_paths.rb

@@ -12,15 +12,15 @@ def test_require_paths
     end
 
     def test_require_relative_paths
-      assert_include ReplCompletion::RequirePaths.require_relative_completions('test_re', binding), 'test_require_paths'
-      assert_include ReplCompletion::RequirePaths.require_relative_completions('../repl_', binding), '../repl_completion/test_require_paths'
-      root_path_binding = eval('binding', binding, File.join(__dir__, '../../Gemfile'), 1)
-      assert_not_include ReplCompletion::RequirePaths.require_relative_completions('li', binding), 'lib/repl_completion'
-      assert_include ReplCompletion::RequirePaths.require_relative_completions('li', root_path_binding), 'lib/repl_completion'
+      assert_include ReplCompletion::RequirePaths.require_relative_completions('test_re', __FILE__), 'test_require_paths'
+      assert_include ReplCompletion::RequirePaths.require_relative_completions('../repl_', __FILE__), '../repl_completion/test_require_paths'
+      project_root = File.expand_path('../../Gemfile', __dir__)
+      assert_not_include ReplCompletion::RequirePaths.require_relative_completions('li', __FILE__), 'lib/repl_completion'
+      assert_include ReplCompletion::RequirePaths.require_relative_completions('li', project_root), 'lib/repl_completion'
       # Incrementally complete deep path
-      assert_include ReplCompletion::RequirePaths.require_relative_completions('li', root_path_binding), 'lib/repl_completion/'
-      assert_not_include ReplCompletion::RequirePaths.require_relative_completions('li', root_path_binding), 'lib/repl_completion/version'
-      assert_include ReplCompletion::RequirePaths.require_relative_completions('lib/', root_path_binding), 'lib/repl_completion/version'
+      assert_include ReplCompletion::RequirePaths.require_relative_completions('li', project_root), 'lib/repl_completion/'
+      assert_not_include ReplCompletion::RequirePaths.require_relative_completions('li', project_root), 'lib/repl_completion/version'
+      assert_include ReplCompletion::RequirePaths.require_relative_completions('lib/', project_root), 'lib/repl_completion/version'
     end
   end
 end