ruby-lsp 0.9.3 → 0.9.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0c2f16b0f0e93ade0e4465fcf71148ac156f6d65b1354f07af2df4007c600c15
-  data.tar.gz: 7c6f4668f461315039e37f04354dddadb1678dd89ff9c249a268897992dfa4c0
+  metadata.gz: 5a300c17567fae60c2ed50c941d8ada19bf6b6fd951b621029880c03afd6d6f5
+  data.tar.gz: 297d0d2064fbe7e97783e26fbfbdbb2191b6a32a43636e743864ad08665f49dd
 SHA512:
-  metadata.gz: 184683630988346ae617e3df3d6d04c66b822d6d9734f595a41caa3603b38046e5ee5a7a4361abede0f3b8d1584371730be9af905d006fa881d4b718f3381947
-  data.tar.gz: 7c10ef841c059110b1d5bc38cde57de243140c37d7095ab8c7ce16d28e4c520c402f2bfcf604f7002a7e06d7db031b8ab9e52ce28bf3c50be0dc2671d5728170
+  metadata.gz: ee884d5c7f60e1d3fac9069a170967a761407a6470b7fe7442686bdbdfc1a4cbd626b7bcd4d368072bce0bab349df935bc0e7e9bdcad7b2fa238143afbc78075
+  data.tar.gz: 317ebe547e3a9730c0161a2ad8b0dd130e819bf92a97c59525e5bc40e1e84bc95e0e610f87f144aebef957a622e141254938954bafd354e7f3d1249e022d2edb

data/VERSION

@@ -1 +1 @@
-0.9.3
+0.9.4

data/lib/ruby_indexer/lib/ruby_indexer/configuration.rb

@@ -24,11 +24,11 @@ module RubyIndexer
 
       @excluded_gems = T.let(excluded_gem_names, T::Array[String])
       @included_gems = T.let([], T::Array[String])
-      @excluded_patterns = T.let(["**/*_test.rb"], T::Array[String])
+      @excluded_patterns = T.let([File.join("**", "*_test.rb")], T::Array[String])
       path = Bundler.settings["path"]
-      @excluded_patterns << "#{File.expand_path(path, Dir.pwd)}/**/*.rb" if path
+      @excluded_patterns << File.join(File.expand_path(path, Dir.pwd), "**", "*.rb") if path
 
-      @included_patterns = T.let(["#{Dir.pwd}/**/*.rb"], T::Array[String])
+      @included_patterns = T.let([File.join(Dir.pwd, "**", "*.rb")], T::Array[String])
       @excluded_magic_comments = T.let(
         [
           "frozen_string_literal:",
@@ -61,8 +61,8 @@ module RubyIndexer
       raise e, "Syntax error while loading .index.yml configuration: #{e.message}"
     end
 
-    sig { returns(T::Array[String]) }
-    def files_to_index
+    sig { returns(T::Array[IndexablePath]) }
+    def indexables
       excluded_gems = @excluded_gems - @included_gems
       locked_gems = Bundler.locked_gems&.specs
 
@@ -70,19 +70,22 @@ module RubyIndexer
       # having duplicates if BUNDLE_PATH is set to a folder inside the project structure
 
       # Add user specified patterns
-      files_to_index = @included_patterns.flat_map do |pattern|
-        Dir.glob(pattern, File::FNM_PATHNAME | File::FNM_EXTGLOB)
+      indexables = @included_patterns.flat_map do |pattern|
+        Dir.glob(pattern, File::FNM_PATHNAME | File::FNM_EXTGLOB).map! do |path|
+          load_path_entry = $LOAD_PATH.find { |load_path| path.start_with?(load_path) }
+          IndexablePath.new(load_path_entry, path)
+        end
       end
 
       # Remove user specified patterns
-      files_to_index.reject! do |path|
+      indexables.reject! do |indexable|
         @excluded_patterns.any? do |pattern|
-          File.fnmatch?(pattern, path, File::FNM_PATHNAME | File::FNM_EXTGLOB)
+          File.fnmatch?(pattern, indexable.full_path, File::FNM_PATHNAME | File::FNM_EXTGLOB)
         end
       end
 
       # Add default gems to the list of files to be indexed
-      Dir.glob("#{RbConfig::CONFIG["rubylibdir"]}/*").each do |default_path|
+      Dir.glob(File.join(RbConfig::CONFIG["rubylibdir"], "*")).each do |default_path|
         # The default_path might be a Ruby file or a folder with the gem's name. For example:
         #   bundler/
         #   bundler.rb
@@ -103,10 +106,14 @@ module RubyIndexer
 
         if pathname.directory?
           # If the default_path is a directory, we index all the Ruby files in it
-          files_to_index.concat(Dir.glob("#{default_path}/**/*.rb", File::FNM_PATHNAME | File::FNM_EXTGLOB))
+          indexables.concat(
+            Dir.glob(File.join(default_path, "**", "*.rb"), File::FNM_PATHNAME | File::FNM_EXTGLOB).map! do |path|
+              IndexablePath.new(RbConfig::CONFIG["rubylibdir"], path)
+            end,
+          )
         else
           # If the default_path is a Ruby file, we index it
-          files_to_index << default_path
+          indexables << IndexablePath.new(RbConfig::CONFIG["rubylibdir"], default_path)
         end
       end
 
@@ -121,15 +128,20 @@ module RubyIndexer
         # duplicates or accidentally ignoring exclude patterns
         next if spec.full_gem_path == Dir.pwd
 
-        files_to_index.concat(Dir.glob("#{spec.full_gem_path}/{#{spec.require_paths.join(",")}}/**/*.rb"))
+        indexables.concat(
+          spec.require_paths.flat_map do |require_path|
+            load_path_entry = File.join(spec.full_gem_path, require_path)
+            Dir.glob(File.join(load_path_entry, "**", "*.rb")).map! { |path| IndexablePath.new(load_path_entry, path) }
+          end,
+        )
       rescue Gem::MissingSpecError
         # If a gem is scoped only to some specific platform, then its dependencies may not be installed either, but they
         # are still listed in locked_gems. We can't index them because they are not installed for the platform, so we
         # just ignore if they're missing
       end
 
-      files_to_index.uniq!
-      files_to_index
+      indexables.uniq!
+      indexables
     end
 
     sig { returns(Regexp) }

data/lib/ruby_indexer/lib/ruby_indexer/index.rb

@@ -17,35 +17,55 @@ module RubyIndexer
       # }
       @entries = T.let({}, T::Hash[String, T::Array[Entry]])
 
+      # Holds all entries in the index using a prefix tree for searching based on prefixes to provide autocompletion
+      @entries_tree = T.let(PrefixTree[T::Array[Entry]].new, PrefixTree[T::Array[Entry]])
+
       # Holds references to where entries where discovered so that we can easily delete them
       # {
       #  "/my/project/foo.rb" => [#<Entry::Class>, #<Entry::Class>],
       #  "/my/project/bar.rb" => [#<Entry::Class>],
       # }
       @files_to_entries = T.let({}, T::Hash[String, T::Array[Entry]])
+
+      # Holds all require paths for every indexed item so that we can provide autocomplete for requires
+      @require_paths_tree = T.let(PrefixTree[String].new, PrefixTree[String])
     end
 
-    sig { params(path: String).void }
-    def delete(path)
+    sig { params(indexable: IndexablePath).void }
+    def delete(indexable)
       # For each constant discovered in `path`, delete the associated entry from the index. If there are no entries
       # left, delete the constant from the index.
-      @files_to_entries[path]&.each do |entry|
-        entries = @entries[entry.name]
+      @files_to_entries[indexable.full_path]&.each do |entry|
+        name = entry.name
+        entries = @entries[name]
         next unless entries
 
         # Delete the specific entry from the list for this name
         entries.delete(entry)
-        # If all entries were deleted, then remove the name from the hash
-        @entries.delete(entry.name) if entries.empty?
+
+        # If all entries were deleted, then remove the name from the hash and from the prefix tree. Otherwise, update
+        # the prefix tree with the current entries
+        if entries.empty?
+          @entries.delete(name)
+          @entries_tree.delete(name)
+        else
+          @entries_tree.insert(name, entries)
+        end
       end
 
-      @files_to_entries.delete(path)
+      @files_to_entries.delete(indexable.full_path)
+
+      require_path = indexable.require_path
+      @require_paths_tree.delete(require_path) if require_path
     end
 
     sig { params(entry: Entry).void }
     def <<(entry)
-      (@entries[entry.name] ||= []) << entry
+      name = entry.name
+
+      (@entries[name] ||= []) << entry
       (@files_to_entries[entry.file_path] ||= []) << entry
+      @entries_tree.insert(name, T.must(@entries[name]))
     end
 
     sig { params(fully_qualified_name: String).returns(T.nilable(T::Array[Entry])) }
@@ -53,6 +73,36 @@ module RubyIndexer
       @entries[fully_qualified_name.delete_prefix("::")]
     end
 
+    sig { params(query: String).returns(T::Array[String]) }
+    def search_require_paths(query)
+      @require_paths_tree.search(query)
+    end
+
+    # Searches entries in the index based on an exact prefix, intended for providing autocomplete. All possible matches
+    # to the prefix are returned. The return is an array of arrays, where each entry is the array of entries for a given
+    # name match. For example:
+    # ## Example
+    # ```ruby
+    # # If the index has two entries for `Foo::Bar` and one for `Foo::Baz`, then:
+    # index.prefix_search("Foo::B")
+    # # Will return:
+    # [
+    #   [#<Entry::Class name="Foo::Bar">, #<Entry::Class name="Foo::Bar">],
+    #   [#<Entry::Class name="Foo::Baz">],
+    # ]
+    # ```
+    sig { params(query: String, nesting: T::Array[String]).returns(T::Array[T::Array[Entry]]) }
+    def prefix_search(query, nesting)
+      results = (nesting.length + 1).downto(0).flat_map do |i|
+        prefix = T.must(nesting[0...i]).join("::")
+        namespaced_query = prefix.empty? ? query : "#{prefix}::#{query}"
+        @entries_tree.search(namespaced_query)
+      end
+
+      results.uniq!
+      results
+    end
+
     # Fuzzy searches index entries based on Jaro-Winkler similarity. If no query is provided, all entries are returned
     sig { params(query: T.nilable(String)).returns(T::Array[Entry]) }
     def fuzzy_search(query)
@@ -85,16 +135,19 @@ module RubyIndexer
       nil
     end
 
-    sig { params(paths: T::Array[String]).void }
-    def index_all(paths: RubyIndexer.configuration.files_to_index)
-      paths.each { |path| index_single(path) }
+    sig { params(indexable_paths: T::Array[IndexablePath]).void }
+    def index_all(indexable_paths: RubyIndexer.configuration.indexables)
+      indexable_paths.each { |path| index_single(path) }
     end
 
-    sig { params(path: String, source: T.nilable(String)).void }
-    def index_single(path, source = nil)
-      content = source || File.read(path)
-      visitor = IndexVisitor.new(self, YARP.parse(content), path)
+    sig { params(indexable_path: IndexablePath, source: T.nilable(String)).void }
+    def index_single(indexable_path, source = nil)
+      content = source || File.read(indexable_path.full_path)
+      visitor = IndexVisitor.new(self, YARP.parse(content), indexable_path.full_path)
       visitor.run
+
+      require_path = indexable_path.require_path
+      @require_paths_tree.insert(require_path, require_path) if require_path
     rescue Errno::EISDIR
       # If `path` is a directory, just ignore it and continue indexing
     end

data/lib/ruby_indexer/lib/ruby_indexer/indexable_path.rb

@@ -0,0 +1,29 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyIndexer
+  class IndexablePath
+    extend T::Sig
+
+    sig { returns(T.nilable(String)) }
+    attr_reader :require_path
+
+    sig { returns(String) }
+    attr_reader :full_path
+
+    # An IndexablePath is instantiated with a load_path_entry and a full_path. The load_path_entry is where the file can
+    # be found in the $LOAD_PATH, which we use to determine the require_path. The load_path_entry may be `nil` if the
+    # indexer is configured to go through files that do not belong in the $LOAD_PATH. For example,
+    # `sorbet/tapioca/require.rb` ends up being a part of the paths to be indexed because it's a Ruby file inside the
+    # project, but the `sorbet` folder is not a part of the $LOAD_PATH. That means that both its load_path_entry and
+    # require_path will be `nil`, since it cannot be required by the project
+    sig { params(load_path_entry: T.nilable(String), full_path: String).void }
+    def initialize(load_path_entry, full_path)
+      @full_path = full_path
+      @require_path = T.let(
+        load_path_entry ? Pathname.new(full_path).relative_path_from(load_path_entry).to_s.delete_suffix(".rb") : nil,
+        T.nilable(String),
+      )
+    end
+  end
+end

data/lib/ruby_indexer/lib/ruby_indexer/prefix_tree.rb

@@ -0,0 +1,153 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyIndexer
+  # A PrefixTree is a data structure that allows searching for partial strings fast. The tree is similar to a nested
+  # hash structure, where the keys are the characters of the inserted strings.
+  #
+  # ## Example
+  # ```ruby
+  # tree = PrefixTree[String].new
+  # # Insert entries using the same key and value
+  # tree.insert("bar", "bar")
+  # tree.insert("baz", "baz")
+  # # Internally, the structure is analogous to this, but using nodes:
+  # # {
+  # #   "b" => {
+  # #     "a" => {
+  # #       "r" => "bar",
+  # #       "z" => "baz"
+  # #     }
+  # #   }
+  # # }
+  # # When we search it, it finds all possible values based on partial (or complete matches):
+  # tree.search("") # => ["bar", "baz"]
+  # tree.search("b") # => ["bar", "baz"]
+  # tree.search("ba") # => ["bar", "baz"]
+  # tree.search("bar") # => ["bar"]
+  # ```
+  #
+  # A PrefixTree is useful for autocomplete, since we always want to find all alternatives while the developer hasn't
+  # finished typing yet. This PrefixTree implementation allows for string keys and any arbitrary value using the generic
+  # `Value` type.
+  #
+  # See https://en.wikipedia.org/wiki/Trie for more information
+  class PrefixTree
+    extend T::Sig
+    extend T::Generic
+
+    Value = type_member
+
+    sig { void }
+    def initialize
+      @root = T.let(Node.new("", ""), Node[Value])
+    end
+
+    # Search the PrefixTree based on a given `prefix`. If `foo` is an entry in the tree, then searching for `fo` will
+    # return it as a result. The result is always an array of the type of value attribute to the generic `Value` type.
+    # Notice that if the `Value` is an array, this method will return an array of arrays, where each entry is the array
+    # of values for a given match
+    sig { params(prefix: String).returns(T::Array[Value]) }
+    def search(prefix)
+      node = find_node(prefix)
+      return [] unless node
+
+      node.collect
+    end
+
+    # Inserts a `value` using the given `key`
+    sig { params(key: String, value: Value).void }
+    def insert(key, value)
+      node = @root
+
+      key.each_char do |char|
+        node = node.children[char] ||= Node.new(char, value, node)
+      end
+
+      # This line is to allow a value to be overridden. When we are indexing files, we want to be able to update entries
+      # for a given fully qualified name if we find more occurrences of it. Without being able to override, that would
+      # not be possible
+      node.value = value
+      node.leaf = true
+    end
+
+    # Deletes the entry identified by `key` from the tree. Notice that a partial match will still delete all entries
+    # that match it. For example, if the tree contains `foo` and we ask to delete `fo`, then `foo` will be deleted
+    sig { params(key: String).void }
+    def delete(key)
+      node = find_node(key)
+      return unless node
+
+      # Remove the node from the tree and then go up the parents to remove any of them with empty children
+      parent = T.let(T.must(node.parent), T.nilable(Node[Value]))
+
+      while parent
+        parent.children.delete(node.key)
+        return if parent.children.any? || parent.leaf
+
+        node = parent
+        parent = parent.parent
+      end
+    end
+
+    private
+
+    # Find a node that matches the given `key`
+    sig { params(key: String).returns(T.nilable(Node[Value])) }
+    def find_node(key)
+      node = @root
+
+      key.each_char do |char|
+        snode = node.children[char]
+        return nil unless snode
+
+        node = snode
+      end
+
+      node
+    end
+
+    class Node
+      extend T::Sig
+      extend T::Generic
+
+      Value = type_member
+
+      sig { returns(T::Hash[String, Node[Value]]) }
+      attr_reader :children
+
+      sig { returns(String) }
+      attr_reader :key
+
+      sig { returns(Value) }
+      attr_accessor :value
+
+      sig { returns(T::Boolean) }
+      attr_accessor :leaf
+
+      sig { returns(T.nilable(Node[Value])) }
+      attr_reader :parent
+
+      sig { params(key: String, value: Value, parent: T.nilable(Node[Value])).void }
+      def initialize(key, value, parent = nil)
+        @key = key
+        @value = value
+        @parent = parent
+        @children = T.let({}, T::Hash[String, Node[Value]])
+        @leaf = T.let(false, T::Boolean)
+      end
+
+      sig { returns(T::Array[Value]) }
+      def collect
+        result = T.let([], T::Array[Value])
+        result << value if leaf
+
+        children.each_value do |node|
+          result.concat(node.collect)
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/ruby_indexer/ruby_indexer.rb

@@ -4,9 +4,11 @@
 require "yaml"
 require "did_you_mean"
 
+require "ruby_indexer/lib/ruby_indexer/indexable_path"
 require "ruby_indexer/lib/ruby_indexer/visitor"
 require "ruby_indexer/lib/ruby_indexer/index"
 require "ruby_indexer/lib/ruby_indexer/configuration"
+require "ruby_indexer/lib/ruby_indexer/prefix_tree"
 
 module RubyIndexer
   class << self

data/lib/ruby_indexer/test/classes_and_modules_test.rb

@@ -139,7 +139,7 @@ module RubyIndexer
 
       assert_entry("Foo", Index::Entry::Class, "/fake/path/foo.rb:0-0:1-2")
 
-      @index.delete("/fake/path/foo.rb")
+      @index.delete(IndexablePath.new(nil, "/fake/path/foo.rb"))
       refute_entry("Foo")
       assert_empty(@index.instance_variable_get(:@files_to_entries))
     end

data/lib/ruby_indexer/test/configuration_test.rb

@@ -11,55 +11,57 @@ module RubyIndexer
 
     def test_load_configuration_executes_configure_block
       @config.load_config
-      files_to_index = @config.files_to_index
+      indexables = @config.indexables
 
-      assert(files_to_index.none? { |path| path.include?("test/fixtures") })
-      assert(files_to_index.none? { |path| path.include?("minitest-reporters") })
-      assert(files_to_index.none? { |path| path == __FILE__ })
+      assert(indexables.none? { |indexable| indexable.full_path.include?("test/fixtures") })
+      assert(indexables.none? { |indexable| indexable.full_path.include?("minitest-reporters") })
+      assert(indexables.none? { |indexable| indexable.full_path == __FILE__ })
     end
 
-    def test_files_to_index_only_includes_gem_require_paths
+    def test_indexables_only_includes_gem_require_paths
       @config.load_config
-      files_to_index = @config.files_to_index
+      indexables = @config.indexables
 
       Bundler.locked_gems.specs.each do |lazy_spec|
         next if lazy_spec.name == "ruby-lsp"
 
         spec = Gem::Specification.find_by_name(lazy_spec.name)
-        assert(files_to_index.none? { |path| path.start_with?("#{spec.full_gem_path}/test/") })
+        assert(indexables.none? { |indexable| indexable.full_path.start_with?("#{spec.full_gem_path}/test/") })
       rescue Gem::MissingSpecError
         # Transitive dependencies might be missing when running tests on Windows
       end
     end
 
-    def test_files_to_index_does_not_include_default_gem_path_when_in_bundle
+    def test_indexables_does_not_include_default_gem_path_when_in_bundle
       @config.load_config
-      files_to_index = @config.files_to_index
+      indexables = @config.indexables
 
-      assert(files_to_index.none? { |path| path.start_with?("#{RbConfig::CONFIG["rubylibdir"]}/psych") })
+      assert(
+        indexables.none? { |indexable| indexable.full_path.start_with?("#{RbConfig::CONFIG["rubylibdir"]}/psych") },
+      )
     end
 
-    def test_files_to_index_includes_default_gems
+    def test_indexables_includes_default_gems
       @config.load_config
-      files_to_index = @config.files_to_index
+      indexables = @config.indexables.map(&:full_path)
 
-      assert_includes(files_to_index, "#{RbConfig::CONFIG["rubylibdir"]}/pathname.rb")
-      assert_includes(files_to_index, "#{RbConfig::CONFIG["rubylibdir"]}/ipaddr.rb")
-      assert_includes(files_to_index, "#{RbConfig::CONFIG["rubylibdir"]}/abbrev.rb")
+      assert_includes(indexables, "#{RbConfig::CONFIG["rubylibdir"]}/pathname.rb")
+      assert_includes(indexables, "#{RbConfig::CONFIG["rubylibdir"]}/ipaddr.rb")
+      assert_includes(indexables, "#{RbConfig::CONFIG["rubylibdir"]}/abbrev.rb")
     end
 
-    def test_files_to_index_includes_project_files
+    def test_indexables_includes_project_files
       @config.load_config
-      files_to_index = @config.files_to_index
+      indexables = @config.indexables.map(&:full_path)
 
       Dir.glob("#{Dir.pwd}/lib/**/*.rb").each do |path|
         next if path.end_with?("_test.rb")
 
-        assert_includes(files_to_index, path)
+        assert_includes(indexables, path)
       end
     end
 
-    def test_files_to_index_avoids_duplicates_if_bundle_path_is_inside_project
+    def test_indexables_avoids_duplicates_if_bundle_path_is_inside_project
       Bundler.settings.set_global("path", "vendor/bundle")
       config = Configuration.new
       config.load_config
@@ -69,18 +71,22 @@ module RubyIndexer
       Bundler.settings.set_global("path", nil)
     end
 
-    def test_files_to_index_does_not_include_gems_own_installed_files
+    def test_indexables_does_not_include_gems_own_installed_files
       @config.load_config
-      files_to_index = @config.files_to_index
+      indexables = @config.indexables
 
-      assert(files_to_index.none? { |path| path.start_with?(Bundler.bundle_path.join("gems", "ruby-lsp").to_s) })
+      assert(
+        indexables.none? do |indexable|
+          indexable.full_path.start_with?(Bundler.bundle_path.join("gems", "ruby-lsp").to_s)
+        end,
+      )
     end
 
     def test_paths_are_unique
       @config.load_config
-      files_to_index = @config.files_to_index
+      indexables = @config.indexables
 
-      assert_equal(files_to_index.uniq.length, files_to_index.length)
+      assert_equal(indexables.uniq.length, indexables.length)
     end
 
     def test_configuration_raises_for_unknown_keys

data/lib/ruby_indexer/test/index_test.rb

@@ -6,11 +6,11 @@ require_relative "test_case"
 module RubyIndexer
   class IndexTest < TestCase
     def test_deleting_one_entry_for_a_class
-      @index.index_single("/fake/path/foo.rb", <<~RUBY)
+      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
         class Foo
         end
       RUBY
-      @index.index_single("/fake/path/other_foo.rb", <<~RUBY)
+      @index.index_single(IndexablePath.new(nil, "/fake/path/other_foo.rb"), <<~RUBY)
         class Foo
         end
       RUBY
@@ -18,13 +18,13 @@ module RubyIndexer
       entries = @index["Foo"]
       assert_equal(2, entries.length)
 
-      @index.delete("/fake/path/other_foo.rb")
+      @index.delete(IndexablePath.new(nil, "/fake/path/other_foo.rb"))
       entries = @index["Foo"]
       assert_equal(1, entries.length)
     end
 
     def test_deleting_all_entries_for_a_class
-      @index.index_single("/fake/path/foo.rb", <<~RUBY)
+      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
         class Foo
         end
       RUBY
@@ -32,13 +32,13 @@ module RubyIndexer
       entries = @index["Foo"]
       assert_equal(1, entries.length)
 
-      @index.delete("/fake/path/foo.rb")
+      @index.delete(IndexablePath.new(nil, "/fake/path/foo.rb"))
       entries = @index["Foo"]
       assert_nil(entries)
     end
 
     def test_index_resolve
-      @index.index_single("/fake/path/foo.rb", <<~RUBY)
+      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
         class Bar; end
 
         module Foo
@@ -72,7 +72,7 @@ module RubyIndexer
     end
 
     def test_accessing_with_colon_colon_prefix
-      @index.index_single("/fake/path/foo.rb", <<~RUBY)
+      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
         class Bar; end
 
         module Foo
@@ -92,7 +92,7 @@ module RubyIndexer
     end
 
     def test_fuzzy_search
-      @index.index_single("/fake/path/foo.rb", <<~RUBY)
+      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
         class Bar; end
 
         module Foo
@@ -121,9 +121,42 @@ module RubyIndexer
 
     def test_index_single_ignores_directories
       FileUtils.mkdir("lib/this_is_a_dir.rb")
-      @index.index_single("lib/this_is_a_dir.rb")
+      @index.index_single(IndexablePath.new(nil, "lib/this_is_a_dir.rb"))
     ensure
       FileUtils.rm_r("lib/this_is_a_dir.rb")
     end
+
+    def test_searching_for_require_paths
+      @index.index_single(IndexablePath.new("/fake", "/fake/path/foo.rb"), <<~RUBY)
+        class Foo
+        end
+      RUBY
+      @index.index_single(IndexablePath.new("/fake", "/fake/path/other_foo.rb"), <<~RUBY)
+        class Foo
+        end
+      RUBY
+
+      assert_equal(["path/foo", "path/other_foo"], @index.search_require_paths("path"))
+    end
+
+    def test_searching_for_entries_based_on_prefix
+      @index.index_single(IndexablePath.new("/fake", "/fake/path/foo.rb"), <<~RUBY)
+        class Foo::Bar
+        end
+      RUBY
+      @index.index_single(IndexablePath.new("/fake", "/fake/path/other_foo.rb"), <<~RUBY)
+        class Foo::Bar
+        end
+
+        class Foo::Baz
+        end
+      RUBY
+
+      results = @index.prefix_search("Foo", []).map { |entries| entries.map(&:name) }
+      assert_equal([["Foo::Bar", "Foo::Bar"], ["Foo::Baz"]], results)
+
+      results = @index.prefix_search("Ba", ["Foo"]).map { |entries| entries.map(&:name) }
+      assert_equal([["Foo::Bar", "Foo::Bar"], ["Foo::Baz"]], results)
+    end
   end
 end

data/lib/ruby_indexer/test/prefix_tree_test.rb

@@ -0,0 +1,150 @@
+# 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[String].new
+      ["foo", "bar", "baz"].each { |item| tree.insert(item, item) }
+
+      assert_equal(["foo", "bar", "baz"], tree.search(""))
+      assert_equal(["bar", "baz"], tree.search("b"))
+      assert_equal(["foo"], tree.search("fo"))
+      assert_equal(["bar", "baz"], tree.search("ba"))
+      assert_equal(["baz"], tree.search("baz"))
+      assert_empty(tree.search("qux"))
+    end
+
+    def test_multiple_prefixes
+      tree = PrefixTree[String].new
+      ["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[String].new
+      [
+        "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/selection",
+          "foo/bar/support/semantic",
+          "foo/bar/support/syntax",
+          "foo/bar/support/source",
+          "foo/bar/support/runner",
+          "foo/bar/support/runner2",
+          "foo/bar/support/rails",
+          "foo/bar/support/diagnostic",
+          "foo/bar/support/highlight",
+          "foo/bar/support/prefix",
+          "foo/bar/support/formatting",
+        ],
+        tree.search("foo/bar/support"),
+      )
+    end
+
+    def test_deletion
+      tree = PrefixTree[String].new
+      ["foo/bar", "foo/baz"].each { |item| tree.insert(item, item) }
+      assert_equal(["foo/bar", "foo/baz"], 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[String].new
+      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[String].new
+      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[String].new
+      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[Integer].new
+
+      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/test_case.rb

@@ -12,7 +12,7 @@ module RubyIndexer
     private
 
     def index(source)
-      @index.index_single("/fake/path/foo.rb", source)
+      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), source)
     end
 
     def assert_entry(expected_name, type, expected_location)

data/lib/ruby_lsp/executor.rb

@@ -191,14 +191,17 @@ module RubyLsp
         file_path = uri.to_standardized_path
         next if file_path.nil? || File.directory?(file_path)
 
+        load_path_entry = $LOAD_PATH.find { |load_path| file_path.start_with?(load_path) }
+        indexable = RubyIndexer::IndexablePath.new(load_path_entry, file_path)
+
         case change[:type]
         when Constant::FileChangeType::CREATED
-          @index.index_single(file_path)
+          @index.index_single(indexable)
         when Constant::FileChangeType::CHANGED
-          @index.delete(file_path)
-          @index.index_single(file_path)
+          @index.delete(indexable)
+          @index.index_single(indexable)
         when Constant::FileChangeType::DELETED
-          @index.delete(file_path)
+          @index.delete(indexable)
         end
       end
 
@@ -300,7 +303,9 @@ module RubyLsp
       hover.response
     end
 
-    sig { params(uri: URI::Generic, content_changes: T::Array[Document::EditShape], version: Integer).returns(Object) }
+    sig do
+      params(uri: URI::Generic, content_changes: T::Array[Document::EditShape], version: Integer).returns(Object)
+    end
     def text_document_did_change(uri, content_changes, version)
       @store.push_edits(uri: uri, edits: content_changes, version: version)
       VOID
@@ -504,7 +509,7 @@ module RubyLsp
       return unless target
 
       emitter = EventEmitter.new
-      listener = Requests::PathCompletion.new(emitter, @message_queue)
+      listener = Requests::PathCompletion.new(@index, emitter, @message_queue)
       emitter.emit_for_target(target)
       listener.response
     end

data/lib/ruby_lsp/extension.rb

@@ -130,7 +130,7 @@ module RubyLsp
       overridable.params(
         emitter: EventEmitter,
         message_queue: Thread::Queue,
-      ).returns(T.nilable(Listener[T.nilable(Interface::DocumentSymbol)]))
+      ).returns(T.nilable(Listener[T::Array[Interface::DocumentSymbol]]))
     end
     def create_document_symbol_listener(emitter, message_queue); end
   end

data/lib/ruby_lsp/requests/path_completion.rb

@@ -22,33 +22,24 @@ module RubyLsp
       sig { override.returns(ResponseType) }
       attr_reader :response
 
-      sig { params(emitter: EventEmitter, message_queue: Thread::Queue).void }
-      def initialize(emitter, message_queue)
-        super
+      sig { params(index: RubyIndexer::Index, emitter: EventEmitter, message_queue: Thread::Queue).void }
+      def initialize(index, emitter, message_queue)
+        super(emitter, message_queue)
         @response = T.let([], ResponseType)
-        @tree = T.let(Support::PrefixTree.new(collect_load_path_files), Support::PrefixTree)
+        @index = index
 
         emitter.register(self, :on_tstring_content)
       end
 
       sig { params(node: SyntaxTree::TStringContent).void }
       def on_tstring_content(node)
-        @tree.search(node.value).sort.each do |path|
+        @index.search_require_paths(node.value).sort!.each do |path|
           @response << build_completion(path, node)
         end
       end
 
       private
 
-      sig { returns(T::Array[String]) }
-      def collect_load_path_files
-        $LOAD_PATH.flat_map do |p|
-          Dir.glob("**/*.rb", base: p)
-        end.map! do |result|
-          result.delete_suffix!(".rb")
-        end
-      end
-
       sig { params(label: String, node: SyntaxTree::TStringContent).returns(Interface::CompletionItem) }
       def build_completion(label, node)
         Interface::CompletionItem.new(

data/lib/ruby_lsp/requests.rb

@@ -53,7 +53,6 @@ module RubyLsp
       autoload :Sorbet, "ruby_lsp/requests/support/sorbet"
       autoload :HighlightTarget, "ruby_lsp/requests/support/highlight_target"
       autoload :RailsDocumentClient, "ruby_lsp/requests/support/rails_document_client"
-      autoload :PrefixTree, "ruby_lsp/requests/support/prefix_tree"
       autoload :Common, "ruby_lsp/requests/support/common"
       autoload :FormatterRunner, "ruby_lsp/requests/support/formatter_runner"
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.9.3
+  version: 0.9.4
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-09-01 00:00:00.000000000 Z
+date: 2023-09-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -67,7 +67,7 @@ dependencies:
         version: '0.9'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: '0.11'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -77,7 +77,7 @@ dependencies:
         version: '0.9'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: '0.11'
 description: An opinionated language server for Ruby
 email:
 - ruby@shopify.com
@@ -97,12 +97,15 @@ files:
 - lib/ruby-lsp.rb
 - lib/ruby_indexer/lib/ruby_indexer/configuration.rb
 - lib/ruby_indexer/lib/ruby_indexer/index.rb
+- lib/ruby_indexer/lib/ruby_indexer/indexable_path.rb
+- lib/ruby_indexer/lib/ruby_indexer/prefix_tree.rb
 - lib/ruby_indexer/lib/ruby_indexer/visitor.rb
 - lib/ruby_indexer/ruby_indexer.rb
 - lib/ruby_indexer/test/classes_and_modules_test.rb
 - lib/ruby_indexer/test/configuration_test.rb
 - lib/ruby_indexer/test/constant_test.rb
 - lib/ruby_indexer/test/index_test.rb
+- lib/ruby_indexer/test/prefix_tree_test.rb
 - lib/ruby_indexer/test/test_case.rb
 - lib/ruby_lsp/check_docs.rb
 - lib/ruby_lsp/document.rb
@@ -135,7 +138,6 @@ files:
 - lib/ruby_lsp/requests/support/dependency_detector.rb
 - lib/ruby_lsp/requests/support/formatter_runner.rb
 - lib/ruby_lsp/requests/support/highlight_target.rb
-- lib/ruby_lsp/requests/support/prefix_tree.rb
 - lib/ruby_lsp/requests/support/rubocop_diagnostic.rb
 - lib/ruby_lsp/requests/support/rubocop_diagnostics_runner.rb
 - lib/ruby_lsp/requests/support/rubocop_formatting_runner.rb
@@ -170,7 +172,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.18
+rubygems_version: 3.4.19
 signing_key: 
 specification_version: 4
 summary: An opinionated language server for Ruby

data/lib/ruby_lsp/requests/support/prefix_tree.rb

@@ -1,80 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module RubyLsp
-  module Requests
-    module Support
-      class PrefixTree
-        extend T::Sig
-
-        sig { params(items: T::Array[String]).void }
-        def initialize(items)
-          @root = T.let(Node.new(""), Node)
-
-          items.each do |item|
-            insert(item)
-          end
-        end
-
-        sig { params(prefix: String).returns(T::Array[String]) }
-        def search(prefix)
-          node = T.let(@root, Node)
-
-          prefix.each_char do |char|
-            snode = node.children[char]
-            return [] unless snode
-
-            node = snode
-          end
-
-          node.collect
-        end
-
-        private
-
-        sig { params(item: String).void }
-        def insert(item)
-          node = T.let(@root, Node)
-
-          item.each_char do |char|
-            node = node.children[char] ||= Node.new(node.value + char)
-          end
-
-          node.leaf = true
-        end
-
-        class Node
-          extend T::Sig
-
-          sig { returns(T::Hash[String, Node]) }
-          attr_reader :children
-
-          sig { returns(String) }
-          attr_reader :value
-
-          sig { returns(T::Boolean) }
-          attr_accessor :leaf
-
-          sig { params(value: String).void }
-          def initialize(value)
-            @children = T.let({}, T::Hash[String, Node])
-            @value = T.let(value, String)
-            @leaf = T.let(false, T::Boolean)
-          end
-
-          sig { returns(T::Array[String]) }
-          def collect
-            result = T.let([], T::Array[String])
-            result << value if leaf
-
-            children.each_value do |node|
-              result.concat(node.collect)
-            end
-
-            result
-          end
-        end
-      end
-    end
-  end
-end