ruby-lsp 0.22.1 → 0.23.0

data/lib/ruby_indexer/test/configuration_test.rb

@@ -13,63 +13,62 @@ module RubyIndexer
 
     def test_load_configuration_executes_configure_block
       @config.apply_config({ "excluded_patterns" => ["**/fixtures/**/*.rb"] })
-      indexables = @config.indexables
+      uris = @config.indexable_uris
 
-      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.include?("ansi") })
-      assert(indexables.any? { |indexable| indexable.full_path.include?("sorbet-runtime") })
-      assert(indexables.none? { |indexable| indexable.full_path == __FILE__ })
+      bundle_path = Bundler.bundle_path.join("gems")
+
+      assert(uris.none? { |uri| uri.full_path.include?("test/fixtures") })
+      assert(uris.none? { |uri| uri.full_path.include?(bundle_path.join("minitest-reporters").to_s) })
+      assert(uris.none? { |uri| uri.full_path.include?(bundle_path.join("ansi").to_s) })
+      assert(uris.any? { |uri| uri.full_path.include?(bundle_path.join("sorbet-runtime").to_s) })
+      assert(uris.none? { |uri| uri.full_path == __FILE__ })
     end
 
-    def test_indexables_have_expanded_full_paths
+    def test_indexable_uris_have_expanded_full_paths
       @config.apply_config({ "included_patterns" => ["**/*.rb"] })
-      indexables = @config.indexables
+      uris = @config.indexable_uris
 
       # All paths should be expanded
-      assert(indexables.all? { |indexable| File.absolute_path?(indexable.full_path) })
+      assert(uris.all? { |uri| File.absolute_path?(uri.full_path) })
     end
 
-    def test_indexables_only_includes_gem_require_paths
-      indexables = @config.indexables
+    def test_indexable_uris_only_includes_gem_require_paths
+      uris = @config.indexable_uris
 
       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(indexables.none? { |indexable| indexable.full_path.start_with?("#{spec.full_gem_path}/test/") })
+        assert(uris.none? { |uri| uri.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_indexables_does_not_include_default_gem_path_when_in_bundle
-      indexables = @config.indexables
-
-      assert(
-        indexables.none? { |indexable| indexable.full_path.start_with?("#{RbConfig::CONFIG["rubylibdir"]}/psych") },
-      )
+    def test_indexable_uris_does_not_include_default_gem_path_when_in_bundle
+      uris = @config.indexable_uris
+      assert(uris.none? { |uri| uri.full_path.start_with?("#{RbConfig::CONFIG["rubylibdir"]}/psych") })
     end
 
-    def test_indexables_includes_default_gems
-      indexables = @config.indexables.map(&:full_path)
+    def test_indexable_uris_includes_default_gems
+      paths = @config.indexable_uris.map(&:full_path)
 
-      assert_includes(indexables, "#{RbConfig::CONFIG["rubylibdir"]}/pathname.rb")
-      assert_includes(indexables, "#{RbConfig::CONFIG["rubylibdir"]}/ipaddr.rb")
-      assert_includes(indexables, "#{RbConfig::CONFIG["rubylibdir"]}/erb.rb")
+      assert_includes(paths, "#{RbConfig::CONFIG["rubylibdir"]}/pathname.rb")
+      assert_includes(paths, "#{RbConfig::CONFIG["rubylibdir"]}/ipaddr.rb")
+      assert_includes(paths, "#{RbConfig::CONFIG["rubylibdir"]}/erb.rb")
     end
 
-    def test_indexables_includes_project_files
-      indexables = @config.indexables.map(&:full_path)
+    def test_indexable_uris_includes_project_files
+      paths = @config.indexable_uris.map(&:full_path)
 
       Dir.glob("#{Dir.pwd}/lib/**/*.rb").each do |path|
         next if path.end_with?("_test.rb")
 
-        assert_includes(indexables, path)
+        assert_includes(paths, path)
       end
     end
 
-    def test_indexables_avoids_duplicates_if_bundle_path_is_inside_project
+    def test_indexable_uris_avoids_duplicates_if_bundle_path_is_inside_project
       Bundler.settings.temporary(path: "vendor/bundle") do
         config = Configuration.new
 
@@ -77,33 +76,32 @@ module RubyIndexer
       end
     end
 
-    def test_indexables_does_not_include_gems_own_installed_files
-      indexables = @config.indexables
-      indexables_inside_bundled_lsp = indexables.select do |indexable|
-        indexable.full_path.start_with?(Bundler.bundle_path.join("gems", "ruby-lsp").to_s)
+    def test_indexable_uris_does_not_include_gems_own_installed_files
+      uris = @config.indexable_uris
+      uris_inside_bundled_lsp = uris.select do |uri|
+        uri.full_path.start_with?(Bundler.bundle_path.join("gems", "ruby-lsp").to_s)
       end
 
       assert_empty(
-        indexables_inside_bundled_lsp,
-        "Indexables should not include files from the gem currently being worked on. " \
-          "Included: #{indexables_inside_bundled_lsp.map(&:full_path)}",
+        uris_inside_bundled_lsp,
+        "Indexable URIs should not include files from the gem currently being worked on. " \
+          "Included: #{uris_inside_bundled_lsp.map(&:full_path)}",
       )
     end
 
-    def test_indexables_does_not_include_non_ruby_files_inside_rubylibdir
+    def test_indexable_uris_does_not_include_non_ruby_files_inside_rubylibdir
       path = Pathname.new(RbConfig::CONFIG["rubylibdir"]).join("extra_file.txt").to_s
       FileUtils.touch(path)
-      indexables = @config.indexables
 
-      assert(indexables.none? { |indexable| indexable.full_path == path })
+      uris = @config.indexable_uris
+      assert(uris.none? { |uri| uri.full_path == path })
     ensure
       FileUtils.rm(T.must(path))
     end
 
     def test_paths_are_unique
-      indexables = @config.indexables
-
-      assert_equal(indexables.uniq.length, indexables.length)
+      uris = @config.indexable_uris
+      assert_equal(uris.uniq.length, uris.length)
     end
 
     def test_configuration_raises_for_unknown_keys
@@ -132,7 +130,7 @@ module RubyIndexer
       end
     end
 
-    def test_indexables_respect_given_workspace_path
+    def test_indexable_uris_respect_given_workspace_path
       Dir.mktmpdir do |dir|
         FileUtils.mkdir(File.join(dir, "ignore"))
         FileUtils.touch(File.join(dir, "ignore", "file0.rb"))
@@ -141,21 +139,21 @@ module RubyIndexer
 
         @config.apply_config({ "excluded_patterns" => ["ignore/**/*.rb"] })
         @config.workspace_path = dir
-        indexables = @config.indexables
 
-        assert(indexables.none? { |indexable| indexable.full_path.start_with?(File.join(dir, "ignore")) })
+        uris = @config.indexable_uris
+        assert(uris.none? { |uri| uri.full_path.start_with?(File.join(dir, "ignore")) })
 
-        # After switching the workspace path, all indexables will be found in one of these places:
+        # After switching the workspace path, all indexable URIs will be found in one of these places:
         # - The new workspace path
         # - The Ruby LSP's own code (because Bundler is requiring the dependency from source)
         # - Bundled gems
         # - Default gems
         assert(
-          indexables.all? do |i|
-            i.full_path.start_with?(dir) ||
-            i.full_path.start_with?(File.join(Dir.pwd, "lib")) ||
-            i.full_path.start_with?(Bundler.bundle_path.to_s) ||
-            i.full_path.start_with?(RbConfig::CONFIG["rubylibdir"])
+          uris.all? do |u|
+            u.full_path.start_with?(dir) ||
+            u.full_path.start_with?(File.join(Dir.pwd, "lib")) ||
+            u.full_path.start_with?(Bundler.bundle_path.to_s) ||
+            u.full_path.start_with?(RbConfig::CONFIG["rubylibdir"])
           end,
         )
       end
@@ -166,8 +164,75 @@ module RubyIndexer
         FileUtils.touch(File.join(dir, "find_me.rb"))
         @config.workspace_path = dir
 
-        indexables = @config.indexables
-        assert(indexables.find { |i| File.basename(i.full_path) == "find_me.rb" })
+        uris = @config.indexable_uris
+        assert(uris.find { |u| File.basename(u.full_path) == "find_me.rb" })
+      end
+    end
+
+    def test_transitive_dependencies_for_non_dev_gems_are_not_excluded
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          # Both IRB and debug depend on reline. Since IRB is in the default group, reline should not be excluded
+          File.write(File.join(dir, "Gemfile"), <<~RUBY)
+            source "https://rubygems.org"
+            gem "irb"
+            gem "ruby-lsp", path: "#{Bundler.root}"
+
+            group :development do
+              gem "debug"
+            end
+          RUBY
+
+          Bundler.with_unbundled_env do
+            capture_subprocess_io do
+              system("bundle install")
+            end
+
+            stdout, _stderr = capture_subprocess_io do
+              script = [
+                "require \"ruby_lsp/internal\"",
+                "print RubyIndexer::Configuration.new.instance_variable_get(:@excluded_gems).join(\",\")",
+              ].join(";")
+              system("bundle exec ruby -e '#{script}'")
+            end
+
+            excluded_gems = stdout.split(",")
+            assert_includes(excluded_gems, "debug")
+            refute_includes(excluded_gems, "reline")
+            refute_includes(excluded_gems, "irb")
+          end
+        end
+      end
+    end
+
+    def test_does_not_fail_if_there_are_missing_specs_due_to_platform_constraints
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          File.write(File.join(dir, "Gemfile"), <<~RUBY)
+            source "https://rubygems.org"
+            gem "ruby-lsp", path: "#{Bundler.root}"
+
+            platforms :windows do
+              gem "tzinfo"
+              gem "tzinfo-data"
+            end
+          RUBY
+
+          Bundler.with_unbundled_env do
+            capture_subprocess_io { system("bundle install") }
+
+            _stdout, stderr = capture_subprocess_io do
+              script = [
+                "require \"ruby_lsp/internal\"",
+                "RubyIndexer::Configuration.new.indexable_uris",
+              ].join(";")
+
+              system("bundle exec ruby -e '#{script}'")
+            end
+
+            assert_empty(stderr)
+          end
+        end
       end
     end
   end

data/lib/ruby_indexer/test/enhancements_test.rb

@@ -172,7 +172,7 @@ module RubyIndexer
       end
 
       assert_match(
-        %r{Indexing error in /fake/path/foo\.rb with 'TestEnhancement' on call node enter enhancement},
+        %r{Indexing error in file:///fake/path/foo\.rb with 'TestEnhancement' on call node enter enhancement},
         stderr,
       )
       # The module should still be indexed
@@ -205,7 +205,7 @@ module RubyIndexer
       end
 
       assert_match(
-        %r{Indexing error in /fake/path/foo\.rb with 'TestEnhancement' on call node leave enhancement},
+        %r{Indexing error in file:///fake/path/foo\.rb with 'TestEnhancement' on call node leave enhancement},
         stderr,
       )
       # The module should still be indexed

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(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb"), <<~RUBY)
         class Foo
         end
       RUBY
-      @index.index_single(IndexablePath.new(nil, "/fake/path/other_foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/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(IndexablePath.new(nil, "/fake/path/other_foo.rb"))
+      @index.delete(URI::Generic.from_path(path: "/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(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/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(IndexablePath.new(nil, "/fake/path/foo.rb"))
+      @index.delete(URI::Generic.from_path(path: "/fake/path/foo.rb"))
       entries = @index["Foo"]
       assert_nil(entries)
     end
 
     def test_index_resolve
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/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(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb"), <<~RUBY)
         class Bar; end
 
         module Foo
@@ -92,7 +92,7 @@ module RubyIndexer
     end
 
     def test_fuzzy_search
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb"), <<~RUBY)
         class Zws; end
 
         module Qtl
@@ -120,18 +120,22 @@ module RubyIndexer
     end
 
     def test_index_single_ignores_directories
-      FileUtils.mkdir("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")
+      path = "#{Dir.pwd}/lib/this_is_a_dir.rb"
+      FileUtils.mkdir(path)
+
+      begin
+        @index.index_file(URI::Generic.from_path(path: path))
+      ensure
+        FileUtils.rm_r(path)
+      end
     end
 
     def test_searching_for_require_paths
-      @index.index_single(IndexablePath.new("/fake", "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb", load_path_entry: "/fake"), <<~RUBY)
         class Foo
         end
       RUBY
-      @index.index_single(IndexablePath.new("/fake", "/fake/path/other_foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/other_foo.rb", load_path_entry: "/fake"), <<~RUBY)
         class Foo
         end
       RUBY
@@ -140,11 +144,11 @@ module RubyIndexer
     end
 
     def test_searching_for_entries_based_on_prefix
-      @index.index_single(IndexablePath.new("/fake", "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb", load_path_entry: "/fake"), <<~RUBY)
         class Foo::Bizw
         end
       RUBY
-      @index.index_single(IndexablePath.new("/fake", "/fake/path/other_foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/other_foo.rb", load_path_entry: "/fake"), <<~RUBY)
         class Foo::Bizw
         end
 
@@ -160,7 +164,7 @@ module RubyIndexer
     end
 
     def test_resolve_normalizes_top_level_names
-      @index.index_single(IndexablePath.new("/fake", "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb", load_path_entry: "/fake"), <<~RUBY)
         class Bar; end
 
         module Foo
@@ -180,7 +184,7 @@ module RubyIndexer
     end
 
     def test_resolving_aliases_to_non_existing_constants_with_conflicting_names
-      @index.index_single(IndexablePath.new("/fake", "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb", load_path_entry: "/fake"), <<~RUBY)
         class Bar
         end
 
@@ -343,18 +347,18 @@ module RubyIndexer
         raise "Prism fixtures not found. Run `git submodule update --init` to fetch them."
       end
 
-      fixtures = Dir.glob("test/fixtures/prism/test/prism/fixtures/**/*.txt")
+      fixtures = Dir.glob("#{Dir.pwd}/test/fixtures/prism/test/prism/fixtures/**/*.txt")
 
       fixtures.each do |fixture|
-        indexable_path = IndexablePath.new("", fixture)
-        @index.index_single(indexable_path)
+        uri = URI::Generic.from_path(path: fixture)
+        @index.index_file(uri)
       end
 
       refute_empty(@index)
     end
 
     def test_index_single_does_not_fail_for_non_existing_file
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"))
+      @index.index_file(URI::Generic.from_path(path: "/fake/path/foo.rb"))
       entries_after_indexing = @index.names
       assert_equal(@default_indexed_entries.keys, entries_after_indexing)
     end
@@ -782,8 +786,8 @@ module RubyIndexer
             end
           RUBY
 
-          indexable_path = IndexablePath.new(nil, File.join(dir, "foo.rb"))
-          @index.index_single(indexable_path)
+          uri = URI::Generic.from_path(path: File.join(dir, "foo.rb"))
+          @index.index_file(uri)
 
           assert_equal(["Bar", "Foo", "Object", "Kernel", "BasicObject"], @index.linearized_ancestors_of("Bar"))
 
@@ -796,7 +800,7 @@ module RubyIndexer
             end
           RUBY
 
-          @index.handle_change(indexable_path)
+          @index.handle_change(uri, File.read(T.must(uri.full_path)))
           assert_empty(@index.instance_variable_get(:@ancestors))
           assert_equal(["Bar", "Object", "Kernel", "BasicObject"], @index.linearized_ancestors_of("Bar"))
         end
@@ -816,8 +820,8 @@ module RubyIndexer
             end
           RUBY
 
-          indexable_path = IndexablePath.new(nil, File.join(dir, "foo.rb"))
-          @index.index_single(indexable_path)
+          uri = URI::Generic.from_path(path: File.join(dir, "foo.rb"))
+          @index.index_file(uri)
 
           assert_equal(["Bar", "Foo", "Object", "Kernel", "BasicObject"], @index.linearized_ancestors_of("Bar"))
 
@@ -833,7 +837,7 @@ module RubyIndexer
             end
           RUBY
 
-          @index.handle_change(indexable_path)
+          @index.handle_change(uri, File.read(T.must(uri.full_path)))
           refute_empty(@index.instance_variable_get(:@ancestors))
           assert_equal(["Bar", "Foo", "Object", "Kernel", "BasicObject"], @index.linearized_ancestors_of("Bar"))
         end
@@ -852,8 +856,8 @@ module RubyIndexer
             end
           RUBY
 
-          indexable_path = IndexablePath.new(nil, File.join(dir, "foo.rb"))
-          @index.index_single(indexable_path)
+          uri = URI::Generic.from_path(path: File.join(dir, "foo.rb"))
+          @index.index_file(uri)
 
           assert_equal(["Bar", "Foo", "Object", "Kernel", "BasicObject"], @index.linearized_ancestors_of("Bar"))
 
@@ -866,7 +870,7 @@ module RubyIndexer
             end
           RUBY
 
-          @index.handle_change(indexable_path)
+          @index.handle_change(uri, File.read(T.must(uri.full_path)))
           assert_empty(@index.instance_variable_get(:@ancestors))
           assert_equal(["Bar", "Object", "Kernel", "BasicObject"], @index.linearized_ancestors_of("Bar"))
         end
@@ -1300,7 +1304,7 @@ module RubyIndexer
     end
 
     def test_resolving_method_inside_singleton_context
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb"), <<~RUBY)
         module Foo
           class Bar
             class << self
@@ -1321,7 +1325,7 @@ module RubyIndexer
     end
 
     def test_resolving_constants_in_singleton_contexts
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb"), <<~RUBY)
         module Foo
           class Bar
             CONST = 3
@@ -1346,7 +1350,7 @@ module RubyIndexer
     end
 
     def test_resolving_instance_variables_in_singleton_contexts
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb"), <<~RUBY)
         module Foo
           class Bar
             @a = 123
@@ -1376,7 +1380,7 @@ module RubyIndexer
     end
 
     def test_instance_variable_completion_in_singleton_contexts
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb"), <<~RUBY)
         module Foo
           class Bar
             @a = 123
@@ -1622,7 +1626,7 @@ module RubyIndexer
     end
 
     def test_linearizing_singleton_ancestors_of_singleton_when_class_has_parent
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb"), <<~RUBY)
         class Foo; end
 
         class Bar < Foo
@@ -1673,7 +1677,7 @@ module RubyIndexer
     end
 
     def test_extend_self
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb"), <<~RUBY)
         module Foo
           def bar
           end
@@ -1705,7 +1709,7 @@ module RubyIndexer
     end
 
     def test_linearizing_singleton_ancestors
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb"), <<~RUBY)
         module First
         end
 
@@ -1746,7 +1750,7 @@ module RubyIndexer
     end
 
     def test_linearizing_singleton_ancestors_when_class_has_parent
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb"), <<~RUBY)
         class Foo; end
 
         class Bar < Foo
@@ -1776,7 +1780,7 @@ module RubyIndexer
     end
 
     def test_linearizing_a_module_singleton_class
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb"), <<~RUBY)
         module A; end
       RUBY
 
@@ -1885,13 +1889,13 @@ module RubyIndexer
         end
       RUBY
 
-      entries = @index.entries_for("/fake/path/foo.rb", Entry)
+      entries = @index.entries_for("file:///fake/path/foo.rb", Entry)
       assert_equal(["Foo", "Bar", "my_def", "Bar::<Class:Bar>", "my_singleton_def"], entries.map(&:name))
 
-      entries = @index.entries_for("/fake/path/foo.rb", RubyIndexer::Entry::Namespace)
+      entries = @index.entries_for("file:///fake/path/foo.rb", RubyIndexer::Entry::Namespace)
       assert_equal(["Foo", "Bar", "Bar::<Class:Bar>"], entries.map(&:name))
 
-      entries = @index.entries_for("/fake/path/foo.rb")
+      entries = @index.entries_for("file:///fake/path/foo.rb")
       assert_equal(["Foo", "Bar", "my_def", "Bar::<Class:Bar>", "my_singleton_def"], entries.map(&:name))
     end
 
@@ -2062,5 +2066,30 @@ module RubyIndexer
         @index.index_all
       end
     end
+
+    def test_index_can_handle_entries_from_untitled_scheme
+      uri = URI("untitled:Untitled-1")
+
+      index(<<~RUBY, uri: uri)
+        class Foo
+        end
+      RUBY
+
+      entry = @index["Foo"]&.first
+      refute_nil(entry, "Expected indexer to be able to handle unsaved URIs")
+      assert_equal("untitled:Untitled-1", entry.uri.to_s)
+      assert_equal("Untitled-1", entry.file_name)
+      assert_nil(entry.file_path)
+
+      @index.handle_change(uri, <<~RUBY)
+        # I added this comment!
+        class Foo
+        end
+      RUBY
+
+      entry = @index["Foo"]&.first
+      refute_nil(entry, "Expected indexer to be able to handle unsaved URIs")
+      assert_equal("I added this comment!", entry.comments)
+    end
   end
 end

data/lib/ruby_indexer/test/rbs_indexer_test.rb

@@ -377,7 +377,7 @@ module RubyIndexer
       _, _, declarations = RBS::Parser.parse_signature(buffer)
       index = RubyIndexer::Index.new
       indexer = RubyIndexer::RBSIndexer.new(index)
-      pathname = Pathname.new("file.rbs")
+      pathname = Pathname.new("/file.rbs")
       indexer.process_signature(pathname, declarations)
       entry = T.must(index[method_name]).first
       T.cast(entry, Entry::Method).signatures

data/lib/ruby_indexer/test/reference_finder_test.rb

@@ -231,7 +231,7 @@ module RubyIndexer
     def find_references(target, source)
       file_path = "/fake.rb"
       index = Index.new
-      index.index_single(IndexablePath.new(nil, file_path), source)
+      index.index_single(URI::Generic.from_path(path: file_path), source)
       parse_result = Prism.parse(source)
       dispatcher = Prism::Dispatcher.new
       finder = ReferenceFinder.new(target, index, dispatcher)

data/lib/ruby_indexer/test/test_case.rb

@@ -13,8 +13,8 @@ module RubyIndexer
 
     private
 
-    def index(source)
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), source)
+    def index(source, uri: URI::Generic.from_path(path: "/fake/path/foo.rb"))
+      @index.index_single(uri, source)
     end
 
     def assert_entry(expected_name, type, expected_location, visibility: nil)