add test

tompng · tompng · commit 6627249cc8c9 · 2023-11-28T19:00:21.000+09:00
diff --git a/test/repl_completion/helper.rb b/test/repl_completion/helper.rb
@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'test/unit'
+require 'core_assertions'
+
+module TestReplCompletion
+  class TestCase < Test::Unit::TestCase
+    include Test::Unit::CoreAssertions
+  end
+end
diff --git a/test/repl_completion/test_repl_completion.rb b/test/repl_completion/test_repl_completion.rb
@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require 'repl_completion'
+require_relative './helper'
+
+module TestReplCompletion
+  class ReplCompletionTest < TestCase
+    def setup
+      ReplCompletion.load_rbs unless ReplCompletion.rbs_loaded?
+    end
+
+    def empty_binding
+      binding
+    end
+
+    TARGET_REGEXP = /(@@|@|\$)?[a-zA-Z_]*[!?=]?$/
+
+    def assert_completion(code, binding: empty_binding, include: nil, exclude: nil)
+      raise ArgumentError if include.nil? && exclude.nil?
+      candidates = ReplCompletion.analyze(code, binding).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('')
+    end
+
+    def test_require
+      assert_completion("require '", include: 'set')
+      assert_completion("require 's", include: 'et')
+      assert_completion("require_relative 'test_", include: 'repl_completion')
+      # Incomplete double quote string is InterpolatedStringNode
+      assert_completion('require "', include: 'set')
+      assert_completion('require "s', include: 'et')
+    end
+
+    def test_method_block_sym
+      assert_completion('[1].map(&:', include: 'abs')
+      assert_completion('[:a].map(&:', exclude: 'abs')
+      assert_completion('[1].map(&:a', include: 'bs')
+      assert_doc_namespace('[1].map(&:abs', 'Integer#abs')
+    end
+
+    def test_symbol
+      prefix = ':test_com'
+      sym = :test_completion_symbol
+      assert_completion(prefix, include: sym.inspect.delete_prefix(prefix))
+    end
+
+    def test_call
+      assert_completion('1.', include: 'abs')
+      assert_completion('1.a', include: 'bs')
+      assert_completion('ran', include: 'd')
+      assert_doc_namespace('1.abs', 'Integer#abs')
+      assert_doc_namespace('Integer.sqrt', 'Integer.sqrt')
+      assert_doc_namespace('rand', 'TestReplCompletion::ReplCompletionTest#rand')
+      assert_doc_namespace('Object::rand', 'Object.rand')
+    end
+
+    def test_lvar
+      bind = eval('lvar = 1; binding')
+      assert_completion('lva', binding: bind, include: 'r')
+      assert_completion('lvar.', binding: bind, include: 'abs')
+      assert_completion('lvar.a', binding: bind, include: 'bs')
+      assert_completion('lvar = ""; lvar.', binding: bind, include: 'ascii_only?')
+      assert_completion('lvar = ""; lvar.', include: 'ascii_only?')
+      assert_doc_namespace('lvar', 'Integer', binding: bind)
+      assert_doc_namespace('lvar.abs', 'Integer#abs', binding: bind)
+      assert_doc_namespace('lvar = ""; lvar.ascii_only?', 'String#ascii_only?', binding: bind)
+    end
+
+    def test_const
+      assert_completion('Ar', include: 'ray')
+      assert_completion('::Ar', include: 'ray')
+      assert_completion('ReplCompletion::V', include: 'ERSION')
+      assert_completion('FooBar=1; F', include: 'ooBar')
+      assert_completion('::FooBar=1; ::F', include: 'ooBar')
+      assert_doc_namespace('Array', 'Array')
+      assert_doc_namespace('Array = 1; Array', 'Integer')
+      assert_doc_namespace('Object::Array', 'Array')
+      assert_completion('::', include: 'Array')
+      assert_completion('class ::', include: 'Array')
+      assert_completion('module ReplCompletion; class T', include: ['ypes', 'racePoint'])
+    end
+
+    def test_gvar
+      assert_completion('$', include: 'stdout')
+      assert_completion('$s', include: 'tdout')
+      assert_completion('$', exclude: 'foobar')
+      assert_completion('$foobar=1; $', include: 'foobar')
+      assert_doc_namespace('$foobar=1; $foobar', 'Integer')
+      assert_doc_namespace('$stdout', 'IO')
+      assert_doc_namespace('$stdout=1; $stdout', 'Integer')
+    end
+
+    def test_ivar
+      bind = Object.new.instance_eval { @foo = 1; binding }
+      assert_completion('@', binding: bind, include: 'foo')
+      assert_completion('@f', binding: bind, include: 'oo')
+      assert_completion('@bar = 1; @', include: 'bar')
+      assert_completion('@bar = 1; @b', include: 'ar')
+      assert_doc_namespace('@bar = 1; @bar', 'Integer')
+      assert_doc_namespace('@foo', 'Integer', binding: bind)
+      assert_doc_namespace('@foo = 1.0; @foo', 'Float', binding: bind)
+    end
+
+    def test_cvar
+      bind = eval('m=Module.new; module m::M; @@foo = 1; binding; end')
+      assert_equal(1, bind.eval('@@foo'))
+      assert_completion('@', binding: bind, include: '@foo')
+      assert_completion('@@', binding: bind, include: 'foo')
+      assert_completion('@@f', binding: bind, include: 'oo')
+      assert_doc_namespace('@@foo', 'Integer', binding: bind)
+      assert_doc_namespace('@@foo = 1.0; @@foo', 'Float', binding: bind)
+      assert_completion('@@bar = 1; @', include: '@bar')
+      assert_completion('@@bar = 1; @@', include: 'bar')
+      assert_completion('@@bar = 1; @@b', include: 'ar')
+      assert_doc_namespace('@@bar = 1; @@bar', 'Integer')
+    end
+
+    def test_basic_object
+      bo = BasicObject.new
+      def bo.foo; end
+      bo.instance_eval { @bar = 1 }
+      bind = binding
+      bo_self_bind = bo.instance_eval { Kernel.binding }
+      assert_completion('bo.', binding: bind, include: 'foo')
+      assert_completion('def bo.baz; self.', binding: bind, include: 'foo')
+      assert_completion('[bo].first.', binding: bind, include: 'foo')
+      assert_doc_namespace('bo', 'BasicObject', binding: bind)
+      assert_doc_namespace('bo.__id__', 'BasicObject#__id__', binding: bind)
+      assert_doc_namespace('v = [bo]; v', 'Array', binding: bind)
+      assert_doc_namespace('v = [bo].first; v', 'BasicObject', binding: bind)
+      bo_self_bind = bo.instance_eval { Kernel.binding }
+      assert_completion('self.', binding: bo_self_bind, include: 'foo')
+      assert_completion('@', binding: bo_self_bind, include: 'bar')
+      assert_completion('@bar.', binding: bo_self_bind, include: 'abs')
+      assert_doc_namespace('self.__id__', 'BasicObject#__id__', binding: bo_self_bind)
+      assert_doc_namespace('@bar', 'Integer', binding: bo_self_bind)
+      if RUBY_VERSION >= '3.2.0' # Needs Class#attached_object to get instance variables from singleton class
+        assert_completion('def bo.baz; @bar.', binding: bind, include: 'abs')
+        assert_completion('def bo.baz; @', binding: bind, include: 'bar')
+      end
+    end
+
+    DEPRECATED_CONST = 1
+    deprecate_constant :DEPRECATED_CONST
+    def test_deprecated_const_without_warning
+      assert_deprecated_warning(/\A\z/) do
+        assert_completion('DEPRECATED', include: '_CONST', binding: binding)
+        assert_completion('DEPRECATED_CONST.a', include: 'bs', binding: binding)
+        assert_doc_namespace('DEPRECATED_CONST', 'Integer', binding: binding)
+      end
+    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__')
+    end
+
+    def test_none
+      result = ReplCompletion.analyze('()', binding)
+      assert_nil result
+    end
+
+    def test_repl_completion_api
+      assert_nil ReplCompletion.rbs_load_error
+      assert_nil ReplCompletion.last_analyze_error
+      assert_equal true, ReplCompletion.rbs_load_started?
+      assert_equal true, ReplCompletion.rbs_loaded?
+      assert_nothing_raised { ReplCompletion.preload_rbs }
+      assert_nothing_raised { ReplCompletion.load_rbs }
+    end
+
+    def test_info
+      assert_equal "ReplCompletion: #{ReplCompletion::VERSION}, Prism: #{Prism::VERSION}, RBS: #{RBS::VERSION}", ReplCompletion.info
+    end
+  end
+end
diff --git a/test/repl_completion/test_require_paths.rb b/test/repl_completion/test_require_paths.rb
@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'repl_completion'
+require_relative './helper'
+
+module TestReplCompletion
+  class RequirePathsTest < TestCase
+    def test_require_paths
+      assert_include ReplCompletion::RequirePaths.require_completions('repl_com'), 'repl_completion'
+      assert_include ReplCompletion::RequirePaths.require_completions('repl_com'), 'repl_completion/version'
+      assert_equal ['repl_completion/version'], ReplCompletion::RequirePaths.require_completions('repl_completion/vers')
+    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'
+      # 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'
+    end
+  end
+end
diff --git a/test/repl_completion/test_scope.rb b/test/repl_completion/test_scope.rb
@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'repl_completion'
+require_relative './helper'
+
+module TestReplCompletion
+  class ScopeTest < TestCase
+    A, B, C, D, E, F, G, H, I, J, K = ('A'..'K').map do |name|
+      klass = Class.new
+      klass.define_singleton_method(:inspect) { name }
+      ReplCompletion::Types::InstanceType.new(klass)
+    end
+
+    def assert_type(expected_types, type)
+      assert_equal [*expected_types].map(&:klass).to_set, type.types.map(&:klass).to_set
+    end
+
+    def table(*local_variable_names)
+      local_variable_names.to_h { [_1, ReplCompletion::Types::NIL] }
+    end
+
+    def base_scope
+      ReplCompletion::RootScope.new(binding, Object.new, [])
+    end
+
+    def test_lvar
+      scope = ReplCompletion::Scope.new base_scope, table('a')
+      scope['a'] = A
+      assert_equal A, scope['a']
+    end
+
+    def test_conditional
+      scope = ReplCompletion::Scope.new base_scope, table('a')
+      scope.conditional do |sub_scope|
+        sub_scope['a'] = A
+      end
+      assert_type [A, ReplCompletion::Types::NIL], scope['a']
+    end
+
+    def test_branch
+      scope = ReplCompletion::Scope.new base_scope, table('a', 'b', 'c', 'd')
+      scope['c'] = A
+      scope['d'] = B
+      scope.run_branches(
+        -> { _1['a'] = _1['c'] = _1['d'] = C },
+        -> { _1['a'] = _1['b'] = _1['d'] = D },
+        -> { _1['a'] = _1['b'] = _1['d'] = E },
+        -> { _1['a'] = _1['b'] = _1['c'] = F; _1.terminate }
+      )
+      assert_type [C, D, E], scope['a']
+      assert_type [ReplCompletion::Types::NIL, D, E], scope['b']
+      assert_type [A, C], scope['c']
+      assert_type [C, D, E], scope['d']
+    end
+
+    def test_scope_local_variables
+      scope1 = ReplCompletion::Scope.new base_scope, table('a', 'b')
+      scope2 = ReplCompletion::Scope.new scope1, table('b', 'c'), trace_lvar: false
+      scope3 = ReplCompletion::Scope.new scope2, table('c', 'd')
+      scope4 = ReplCompletion::Scope.new scope2, table('d', 'e')
+      assert_empty base_scope.local_variables
+      assert_equal %w[a b], scope1.local_variables.sort
+      assert_equal %w[b c], scope2.local_variables.sort
+      assert_equal %w[b c d], scope3.local_variables.sort
+      assert_equal %w[b c d e], scope4.local_variables.sort
+    end
+
+    def test_nested_scope
+      scope = ReplCompletion::Scope.new base_scope, table('a', 'b', 'c')
+      scope['a'] = A
+      scope['b'] = A
+      scope['c'] = A
+      sub_scope = ReplCompletion::Scope.new scope, { 'c' => B }
+      assert_type A, sub_scope['a']
+
+      assert_type A, sub_scope['b']
+      assert_type B, sub_scope['c']
+      sub_scope['a'] = C
+      sub_scope.conditional { _1['b'] = C }
+      sub_scope['c'] = C
+      assert_type C, sub_scope['a']
+      assert_type [A, C], sub_scope['b']
+      assert_type C, sub_scope['c']
+      scope.update sub_scope
+      assert_type C, scope['a']
+      assert_type [A, C], scope['b']
+      assert_type A, scope['c']
+    end
+
+    def test_break
+      scope = ReplCompletion::Scope.new base_scope, table('a')
+      scope['a'] = A
+      breakable_scope = ReplCompletion::Scope.new scope, { ReplCompletion::Scope::BREAK_RESULT => nil }
+      breakable_scope.conditional do |sub|
+        sub['a'] = B
+        assert_type [B], sub['a']
+        sub.terminate_with ReplCompletion::Scope::BREAK_RESULT, C
+        sub['a'] = C
+        assert_type [C], sub['a']
+      end
+      assert_type [A], breakable_scope['a']
+      breakable_scope[ReplCompletion::Scope::BREAK_RESULT] = D
+      breakable_scope.merge_jumps
+      assert_type [C, D], breakable_scope[ReplCompletion::Scope::BREAK_RESULT]
+      scope.update breakable_scope
+      assert_type [A, B], scope['a']
+    end
+  end
+end
diff --git a/test/repl_completion/test_type_analyze.rb b/test/repl_completion/test_type_analyze.rb
diff --git a/test/repl_completion/test_types.rb b/test/repl_completion/test_types.rb
