ruby-lsp 0.26.5 → 0.26.7

data/lib/ruby_indexer/test/prefix_tree_test.rb

@@ -1,150 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-require "test_helper"
-
-module RubyIndexer
-  class PrefixTreeTest < Minitest::Test
-    def test_empty
-      tree = PrefixTree.new
-
-      assert_empty(tree.search(""))
-      assert_empty(tree.search("foo"))
-    end
-
-    def test_single_item
-      tree = PrefixTree.new
-      tree.insert("foo", "foo")
-
-      assert_equal(["foo"], tree.search(""))
-      assert_equal(["foo"], tree.search("foo"))
-      assert_empty(tree.search("bar"))
-    end
-
-    def test_multiple_items
-      tree = PrefixTree.new #: PrefixTree[String]
-      ["foo", "bar", "baz"].each { |item| tree.insert(item, item) }
-
-      assert_equal(["baz", "bar", "foo"], tree.search(""))
-      assert_equal(["baz", "bar"], tree.search("b"))
-      assert_equal(["foo"], tree.search("fo"))
-      assert_equal(["baz", "bar"], tree.search("ba"))
-      assert_equal(["baz"], tree.search("baz"))
-      assert_empty(tree.search("qux"))
-    end
-
-    def test_multiple_prefixes
-      tree = PrefixTree.new #: PrefixTree[String]
-      ["fo", "foo"].each { |item| tree.insert(item, item) }
-
-      assert_equal(["fo", "foo"], tree.search(""))
-      assert_equal(["fo", "foo"], tree.search("f"))
-      assert_equal(["fo", "foo"], tree.search("fo"))
-      assert_equal(["foo"], tree.search("foo"))
-      assert_empty(tree.search("fooo"))
-    end
-
-    def test_multiple_prefixes_with_shuffled_order
-      tree = PrefixTree.new #: PrefixTree[String]
-      [
-        "foo/bar/base",
-        "foo/bar/on",
-        "foo/bar/support/selection",
-        "foo/bar/support/runner",
-        "foo/internal",
-        "foo/bar/document",
-        "foo/bar/code",
-        "foo/bar/support/rails",
-        "foo/bar/diagnostics",
-        "foo/bar/document2",
-        "foo/bar/support/runner2",
-        "foo/bar/support/diagnostic",
-        "foo/document",
-        "foo/bar/formatting",
-        "foo/bar/support/highlight",
-        "foo/bar/semantic",
-        "foo/bar/support/prefix",
-        "foo/bar/folding",
-        "foo/bar/selection",
-        "foo/bar/support/syntax",
-        "foo/bar/document3",
-        "foo/bar/hover",
-        "foo/bar/support/semantic",
-        "foo/bar/support/source",
-        "foo/bar/inlay",
-        "foo/requests",
-        "foo/bar/support/formatting",
-        "foo/bar/path",
-        "foo/executor",
-      ].each { |item| tree.insert(item, item) }
-
-      assert_equal(
-        [
-          "foo/bar/support/formatting",
-          "foo/bar/support/prefix",
-          "foo/bar/support/highlight",
-          "foo/bar/support/diagnostic",
-          "foo/bar/support/rails",
-          "foo/bar/support/runner",
-          "foo/bar/support/runner2",
-          "foo/bar/support/source",
-          "foo/bar/support/syntax",
-          "foo/bar/support/semantic",
-          "foo/bar/support/selection",
-        ],
-        tree.search("foo/bar/support"),
-      )
-    end
-
-    def test_deletion
-      tree = PrefixTree.new #: PrefixTree[String]
-      ["foo/bar", "foo/baz"].each { |item| tree.insert(item, item) }
-      assert_equal(["foo/baz", "foo/bar"], tree.search("foo"))
-
-      tree.delete("foo/bar")
-      assert_empty(tree.search("foo/bar"))
-      assert_equal(["foo/baz"], tree.search("foo"))
-    end
-
-    def test_delete_does_not_impact_other_keys_with_the_same_value
-      tree = PrefixTree.new #: PrefixTree[String]
-      tree.insert("key1", "value")
-      tree.insert("key2", "value")
-      assert_equal(["value", "value"], tree.search("key"))
-
-      tree.delete("key2")
-      assert_empty(tree.search("key2"))
-      assert_equal(["value"], tree.search("key1"))
-    end
-
-    def test_deleted_node_is_removed_from_the_tree
-      tree = PrefixTree.new #: PrefixTree[String]
-      tree.insert("foo/bar", "foo/bar")
-      assert_equal(["foo/bar"], tree.search("foo"))
-
-      tree.delete("foo/bar")
-      root = tree.instance_variable_get(:@root)
-      assert_empty(root.children)
-    end
-
-    def test_deleting_non_terminal_nodes
-      tree = PrefixTree.new #: PrefixTree[String]
-      tree.insert("abc", "value1")
-      tree.insert("abcdef", "value2")
-
-      tree.delete("abcdef")
-      assert_empty(tree.search("abcdef"))
-      assert_equal(["value1"], tree.search("abc"))
-    end
-
-    def test_overriding_values
-      tree = PrefixTree.new #: PrefixTree[Integer]
-
-      tree.insert("foo/bar", 123)
-      assert_equal([123], tree.search("foo/bar"))
-
-      tree.insert("foo/bar", 456)
-      assert_equal([456], tree.search("foo/bar"))
-    end
-  end
-end

data/lib/ruby_indexer/test/rbs_indexer_test.rb

@@ -1,381 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-require_relative "test_case"
-
-module RubyIndexer
-  class RBSIndexerTest < TestCase
-    def test_index_core_classes
-      entries = @index["Array"] #: as !nil
-      refute_nil(entries)
-      # Array is a class but also an instance method on Kernel
-      assert_equal(2, entries.length)
-      entry = entries.find { |entry| entry.is_a?(Entry::Class) } #: as Entry::Class
-      assert_match(%r{/gems/rbs-.*/core/array.rbs}, entry.file_path)
-      assert_equal("array.rbs", entry.file_name)
-      assert_equal("Object", entry.parent_class)
-      assert_equal(1, entry.mixin_operations.length)
-      enumerable_include = entry.mixin_operations.first #: as !nil
-      assert_equal("Enumerable", enumerable_include.module_name)
-
-      # Using fixed positions would be fragile, so let's just check some basics.
-      assert_operator(entry.location.start_line, :>, 0)
-      assert_operator(entry.location.end_line, :>, entry.location.start_line)
-      assert_equal(0, entry.location.start_column)
-      assert_operator(entry.location.end_column, :>, 0)
-    end
-
-    def test_index_core_modules
-      entries = @index["Kernel"] #: as !nil
-      refute_nil(entries)
-      assert_equal(2, entries.length)
-      entry = entries.first #: as Entry::Module
-      assert_match(%r{/gems/rbs-.*/core/kernel.rbs}, entry.file_path)
-      assert_equal("kernel.rbs", entry.file_name)
-
-      # Using fixed positions would be fragile, so let's just check some basics.
-      assert_operator(entry.location.start_line, :>, 0)
-      assert_operator(entry.location.end_line, :>, entry.location.start_line)
-      assert_equal(0, entry.location.start_column)
-      assert_operator(entry.location.end_column, :>, 0)
-    end
-
-    def test_index_core_constants
-      entries = @index["RUBY_VERSION"] #: as !nil
-      refute_nil(entries)
-      assert_equal(1, entries.length)
-
-      entries = @index["Complex::I"] #: as !nil
-      refute_nil(entries)
-      assert_equal(1, entries.length)
-
-      entries = @index["Encoding::US_ASCII"] #: as !nil
-      refute_nil(entries)
-      assert_equal(1, entries.length)
-    end
-
-    def test_index_methods
-      entries = @index["initialize"] #: as Array[Entry::Method]
-      refute_nil(entries)
-      entry = entries.find { |entry| entry.owner&.name == "Array" } #: as Entry::Method
-      assert_match(%r{/gems/rbs-.*/core/array.rbs}, entry.file_path)
-      assert_equal("array.rbs", entry.file_name)
-      assert_equal(:public, entry.visibility)
-
-      # Using fixed positions would be fragile, so let's just check some basics.
-      assert_operator(entry.location.start_line, :>, 0)
-      assert_operator(entry.location.end_line, :>, entry.location.start_line)
-      assert_equal(2, entry.location.start_column)
-      assert_operator(entry.location.end_column, :>, 0)
-    end
-
-    def test_index_global_declaration
-      entries = @index["$DEBUG"] #: as Array[Entry::GlobalVariable]
-      refute_nil(entries)
-      assert_equal(1, entries.length)
-
-      entry = entries.first #: as Entry::GlobalVariable
-
-      assert_instance_of(Entry::GlobalVariable, entry)
-      assert_equal("$DEBUG", entry.name)
-      assert_match(%r{/gems/rbs-.*/core/global_variables.rbs}, entry.file_path)
-      assert_operator(entry.location.start_column, :<, entry.location.end_column)
-      assert_equal(entry.location.start_line, entry.location.end_line)
-    end
-
-    def test_attaches_correct_owner_to_singleton_methods
-      entries = @index["basename"] #: as Array[Entry::Method]
-      refute_nil(entries)
-
-      owner = entries.first&.owner #: as Entry::SingletonClass
-      assert_instance_of(Entry::SingletonClass, owner)
-      assert_equal("File::<Class:File>", owner.name)
-    end
-
-    def test_location_and_name_location_are_the_same
-      # NOTE: RBS does not store the name location for classes, modules or methods. This behavior is not exactly what
-      # we would like, but for now we assign the same location to both
-
-      entries = @index["Array"] #: as Array[Entry::Class]
-      refute_nil(entries)
-      entry = entries.find { |entry| entry.is_a?(Entry::Class) } #: as Entry::Class
-
-      assert_same(entry.location, entry.name_location)
-    end
-
-    def test_rbs_method_with_required_positionals
-      entries = @index["crypt"] #: as Array[Entry::Method]
-      assert_equal(1, entries.length)
-
-      entry = entries.first #: as Entry::Method
-      signatures = entry.signatures
-      assert_equal(1, signatures.length)
-
-      first_signature = signatures.first #: as Entry::Signature
-
-      # (::string salt_str) -> ::String
-
-      assert_equal(1, first_signature.parameters.length)
-      assert_kind_of(Entry::RequiredParameter, first_signature.parameters[0])
-      assert_equal(:salt_str, first_signature.parameters[0]&.name)
-    end
-
-    def test_rbs_method_with_unnamed_required_positionals
-      entries = @index["try_convert"] #: as Array[Entry::Method]
-      entry = entries.find { |entry| entry.owner&.name == "Array::<Class:Array>" } #: as Entry::Method
-
-      parameters = entry.signatures[0]&.parameters #: as Array[Entry::Parameter]
-
-      assert_equal([:arg0], parameters.map(&:name))
-      assert_kind_of(Entry::RequiredParameter, parameters[0])
-    end
-
-    def test_rbs_method_with_optional_positionals
-      entries = @index["polar"] #: as Array[Entry::Method]
-      entry = entries.find { |entry| entry.owner&.name == "Complex::<Class:Complex>" } #: as Entry::Method
-
-      # def self.polar: (Numeric, ?Numeric) -> Complex
-
-      parameters = entry.signatures[0]&.parameters #: as Array[Entry::Parameter]
-
-      assert_equal([:arg0, :arg1], parameters.map(&:name))
-      assert_kind_of(Entry::RequiredParameter, parameters[0])
-      assert_kind_of(Entry::OptionalParameter, parameters[1])
-    end
-
-    def test_rbs_method_with_optional_parameter
-      entries = @index["chomp"] #: as Array[Entry::Method]
-      assert_equal(1, entries.length)
-
-      entry = entries.first #: as Entry::Method
-      signatures = entry.signatures
-      assert_equal(1, signatures.length)
-
-      first_signature = signatures.first #: as Entry::Signature
-
-      # (?::string? separator) -> ::String
-
-      assert_equal(1, first_signature.parameters.length)
-      assert_kind_of(Entry::OptionalParameter, first_signature.parameters[0])
-      assert_equal(:separator, first_signature.parameters[0]&.name)
-    end
-
-    def test_rbs_method_with_required_and_optional_parameters
-      entries = @index["gsub"] #: as Array[Entry::Method]
-      assert_equal(1, entries.length)
-
-      entry = entries.first #: as Entry::Method
-
-      signatures = entry.signatures
-      assert_equal(3, signatures.length)
-
-      # (::Regexp | ::string pattern, ::string | ::hash[::String, ::_ToS] replacement) -> ::String
-      # | (::Regexp | ::string pattern) -> ::Enumerator[::String, ::String]
-      # | (::Regexp | ::string pattern) { (::String match) -> ::_ToS } -> ::String
-
-      parameters = signatures[0]&.parameters #: as !nil
-      assert_equal([:pattern, :replacement], parameters.map(&:name))
-      assert_kind_of(Entry::RequiredParameter, parameters[0])
-      assert_kind_of(Entry::RequiredParameter, parameters[1])
-
-      parameters = signatures[1]&.parameters #: as !nil
-      assert_equal([:pattern], parameters.map(&:name))
-      assert_kind_of(Entry::RequiredParameter, parameters[0])
-
-      parameters = signatures[2]&.parameters #: as !nil
-      assert_equal([:pattern, :"<anonymous block>"], parameters.map(&:name))
-      assert_kind_of(Entry::RequiredParameter, parameters[0])
-      assert_kind_of(Entry::BlockParameter, parameters[1])
-    end
-
-    def test_rbs_anonymous_block_parameter
-      entries = @index["open"] #: as Array[Entry::Method]
-      entry = entries.find { |entry| entry.owner&.name == "File::<Class:File>" } #: as Entry::Method
-
-      assert_equal(2, entry.signatures.length)
-
-      # (::String name, ?::String mode, ?::Integer perm) -> ::IO?
-      # | [T] (::String name, ?::String mode, ?::Integer perm) { (::IO) -> T } -> T
-
-      parameters = entry.signatures[0]&.parameters #: as !nil
-      assert_equal([:file_name, :mode, :perm], parameters.map(&:name))
-      assert_kind_of(Entry::RequiredParameter, parameters[0])
-      assert_kind_of(Entry::OptionalParameter, parameters[1])
-      assert_kind_of(Entry::OptionalParameter, parameters[2])
-
-      parameters = entry.signatures[1]&.parameters #: as !nil
-      assert_equal([:file_name, :mode, :perm, :"<anonymous block>"], parameters.map(&:name))
-      assert_kind_of(Entry::RequiredParameter, parameters[0])
-      assert_kind_of(Entry::OptionalParameter, parameters[1])
-      assert_kind_of(Entry::OptionalParameter, parameters[2])
-      assert_kind_of(Entry::BlockParameter, parameters[3])
-    end
-
-    def test_rbs_method_with_rest_positionals
-      entries = @index["count"] #: as Array[Entry::Method]
-      entry = entries.find { |entry| entry.owner&.name == "String" } #: as Entry::Method
-
-      parameters = entry.signatures.first&.parameters #: as !nil
-      assert_equal(1, entry.signatures.length)
-
-      # (::String::selector selector_0, *::String::selector more_selectors) -> ::Integer
-
-      assert_equal([:selector_0, :more_selectors], parameters.map(&:name))
-      assert_kind_of(RubyIndexer::Entry::RequiredParameter, parameters[0])
-      assert_kind_of(RubyIndexer::Entry::RestParameter, parameters[1])
-    end
-
-    def test_rbs_method_with_trailing_positionals
-      entries = @index["select"] #: as Array[Entry::Method]
-      entry = entries.find { |entry| entry.owner&.name == "IO::<Class:IO>" } #: as !nil
-
-      signatures = entry.signatures
-      assert_equal(2, signatures.length)
-
-      # def self.select: [X, Y, Z] (::Array[X & io]? read_array, ?::Array[Y & io]? write_array, ?::Array[Z & io]? error_array) -> [ Array[X], Array[Y], Array[Z] ]
-      #   | [X, Y, Z] (::Array[X & io]? read_array, ?::Array[Y & io]? write_array, ?::Array[Z & io]? error_array, Time::_Timeout? timeout) -> [ Array[X], Array[Y], Array[Z] ]?
-
-      parameters = signatures[0]&.parameters #: as !nil
-      assert_equal([:read_array, :write_array, :error_array], parameters.map(&:name))
-      assert_kind_of(Entry::RequiredParameter, parameters[0])
-      assert_kind_of(Entry::OptionalParameter, parameters[1])
-      assert_kind_of(Entry::OptionalParameter, parameters[2])
-
-      parameters = signatures[1]&.parameters #: as !nil
-      assert_equal([:read_array, :write_array, :error_array, :timeout], parameters.map(&:name))
-      assert_kind_of(Entry::RequiredParameter, parameters[0])
-      assert_kind_of(Entry::OptionalParameter, parameters[1])
-      assert_kind_of(Entry::OptionalParameter, parameters[2])
-      assert_kind_of(Entry::OptionalParameter, parameters[3])
-    end
-
-    def test_rbs_method_with_optional_keywords
-      entries = @index["step"] #: as Array[Entry::Method]
-      entry = entries.find { |entry| entry.owner&.name == "Numeric" } #: as !nil
-
-      signatures = entry.signatures
-      assert_equal(4, signatures.length)
-
-      # (?::Numeric limit, ?::Numeric step) { (::Numeric) -> void } -> self
-      # | (?::Numeric limit, ?::Numeric step) -> ::Enumerator[::Numeric, self]
-      # | (?by: ::Numeric, ?to: ::Numeric) { (::Numeric) -> void } -> self
-      # | (?by: ::Numeric, ?to: ::Numeric) -> ::Enumerator[::Numeric, self]
-
-      parameters = signatures[0]&.parameters #: as !nil
-      assert_equal([:limit, :step, :"<anonymous block>"], parameters.map(&:name))
-      assert_kind_of(Entry::OptionalParameter, parameters[0])
-      assert_kind_of(Entry::OptionalParameter, parameters[1])
-      assert_kind_of(Entry::BlockParameter, parameters[2])
-
-      parameters = signatures[1]&.parameters #: as !nil
-      assert_equal([:limit, :step], parameters.map(&:name))
-      assert_kind_of(Entry::OptionalParameter, parameters[0])
-      assert_kind_of(Entry::OptionalParameter, parameters[1])
-
-      parameters = signatures[2]&.parameters #: as !nil
-      assert_equal([:by, :to, :"<anonymous block>"], parameters.map(&:name))
-      assert_kind_of(Entry::OptionalKeywordParameter, parameters[0])
-      assert_kind_of(Entry::OptionalKeywordParameter, parameters[1])
-      assert_kind_of(Entry::BlockParameter, parameters[2])
-
-      parameters = signatures[3]&.parameters #: as !nil
-      assert_equal([:by, :to], parameters.map(&:name))
-      assert_kind_of(Entry::OptionalKeywordParameter, parameters[0])
-      assert_kind_of(Entry::OptionalKeywordParameter, parameters[1])
-    end
-
-    def test_rbs_method_with_required_keywords
-      # There are no methods in Core that have required keyword arguments,
-      # so we test against RBS directly
-
-      rbs = <<~RBS
-        class File
-          def foo: (a: ::Numeric sz, b: ::Numeric) -> void
-        end
-      RBS
-      signatures = parse_rbs_methods(rbs, "foo")
-      parameters = signatures[0].parameters
-      assert_equal([:a, :b], parameters.map(&:name))
-      assert_kind_of(Entry::KeywordParameter, parameters[0])
-      assert_kind_of(Entry::KeywordParameter, parameters[1])
-    end
-
-    def test_rbs_method_with_rest_keywords
-      entries = @index["method_missing"] #: as Array[Entry::Method]
-      entry = entries.find { |entry| entry.owner&.name == "BasicObject" } #: as !nil
-      signatures = entry.signatures
-      assert_equal(1, signatures.length)
-
-      # (Symbol, *untyped, **untyped) ?{ (*untyped, **untyped) -> untyped } -> untyped
-
-      parameters = signatures[0]&.parameters #: as !nil
-      assert_equal([:arg0, :"<anonymous splat>", :"<anonymous keyword splat>"], parameters.map(&:name))
-      assert_kind_of(Entry::RequiredParameter, parameters[0])
-      assert_kind_of(Entry::RestParameter, parameters[1])
-      assert_kind_of(Entry::KeywordRestParameter, parameters[2])
-    end
-
-    def test_parse_simple_rbs
-      rbs = <<~RBS
-        class File
-          def self?.open: (String name, ?String mode, ?Integer perm) -> IO?
-              | [T] (String name, ?String mode, ?Integer perm) { (IO) -> T } -> T
-        end
-      RBS
-      signatures = parse_rbs_methods(rbs, "open")
-      assert_equal(2, signatures.length)
-      parameters = signatures[0].parameters
-      assert_equal([:name, :mode, :perm], parameters.map(&:name))
-      assert_kind_of(Entry::RequiredParameter, parameters[0])
-      assert_kind_of(Entry::OptionalParameter, parameters[1])
-      assert_kind_of(Entry::OptionalParameter, parameters[2])
-
-      parameters = signatures[1].parameters
-      assert_equal([:name, :mode, :perm, :"<anonymous block>"], parameters.map(&:name))
-      assert_kind_of(Entry::RequiredParameter, parameters[0])
-      assert_kind_of(Entry::OptionalParameter, parameters[1])
-      assert_kind_of(Entry::OptionalParameter, parameters[2])
-      assert_kind_of(Entry::BlockParameter, parameters[3])
-    end
-
-    def test_signature_alias
-      # In RBS, an alias means that two methods have the same signature.
-      # It does not mean the same thing as a Ruby alias.
-      any_entries = @index["any?"] #: as Array[Entry::UnresolvedMethodAlias]
-
-      assert_equal(["Array", "Enumerable", "Hash"], any_entries.map { _1.owner&.name })
-
-      entry = any_entries.find { |entry| entry.owner&.name == "Array" } #: as !nil
-
-      assert_kind_of(RubyIndexer::Entry::UnresolvedMethodAlias, entry)
-      assert_equal("any?", entry.name)
-      assert_equal("all?", entry.old_name)
-      assert_equal("Array", entry.owner&.name)
-      assert(entry.file_path&.end_with?("core/array.rbs"))
-      refute_empty(entry.comments)
-    end
-
-    def test_indexing_untyped_functions
-      entries = @index.resolve_method("call", "Method") #: as Array[Entry::Method]
-
-      parameters = entries.first&.signatures&.first&.parameters #: as !nil
-      assert_equal(1, parameters.length)
-      assert_instance_of(Entry::ForwardingParameter, parameters.first)
-    end
-
-    private
-
-    def parse_rbs_methods(rbs, method_name)
-      buffer = RBS::Buffer.new(content: rbs, name: "")
-      _, _, declarations = RBS::Parser.parse_signature(buffer)
-      index = RubyIndexer::Index.new
-      indexer = RubyIndexer::RBSIndexer.new(index)
-      pathname = Pathname.new("/file.rbs")
-      indexer.process_signature(pathname, declarations)
-      entry = index[method_name] #: as !nil
-        .first #: as Entry::Method
-
-      entry.signatures
-    end
-  end
-end