ruby-lsp 0.9.3 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0c2f16b0f0e93ade0e4465fcf71148ac156f6d65b1354f07af2df4007c600c15
-  data.tar.gz: 7c6f4668f461315039e37f04354dddadb1678dd89ff9c249a268897992dfa4c0
+  metadata.gz: 98731986ff16a22d1854fe971bfa188d55212665128ad635aabbf519c1097d9f
+  data.tar.gz: fe416e79e672448b3d2477909fec47451c6f878020ec92e2178259d933c51cb4
 SHA512:
-  metadata.gz: 184683630988346ae617e3df3d6d04c66b822d6d9734f595a41caa3603b38046e5ee5a7a4361abede0f3b8d1584371730be9af905d006fa881d4b718f3381947
-  data.tar.gz: 7c10ef841c059110b1d5bc38cde57de243140c37d7095ab8c7ce16d28e4c520c402f2bfcf604f7002a7e06d7db031b8ab9e52ce28bf3c50be0dc2671d5728170
+  metadata.gz: ad9a36886ffb6b1370b2530ffdb84a89244e22ec2329ee111d70bea8e90ad7ebe6c92b87dd437e283270cb09a7d564b3471d7ddcdc51df86df54d4bdfd09ada8
+  data.tar.gz: 9a89e7a763d1a74a320ca8dd544a52ead86a3bd573204ad86585dce7dc7797ac993f3716b98e9e6cdfd9d5b6b7a8f17e9743aa149866945d099e7d9210719a28

data/VERSION

@@ -1 +1 @@
-0.9.3
+0.10.0

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[IndexablePath].new, PrefixTree[IndexablePath])
     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[IndexablePath]) }
+    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, indexable_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").map(&:require_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