ruby-lsp 0.23.10 → 0.23.14

data/lib/ruby_indexer/lib/ruby_indexer/uri.rb

@@ -1,35 +1,33 @@
 # typed: strict
 # frozen_string_literal: true
 
+require "uri"
+
 module URI
   class Generic
-    extend T::Sig
-
     # Avoid a deprecation warning with Ruby 3.4 where the default parser was changed to RFC3986.
     # This condition must remain even after support for 3.4 has been dropped for users that have
     # `uri` in their lockfile, decoupling it from the ruby version.
-    PARSER = T.let(const_defined?(:RFC2396_PARSER) ? RFC2396_PARSER : DEFAULT_PARSER, RFC2396_Parser)
 
-    class << self
-      extend T::Sig
+    # NOTE: We also define this in the shim
+    PARSER = const_defined?(:RFC2396_PARSER) ? RFC2396_PARSER : DEFAULT_PARSER
 
-      sig do
-        params(
-          path: String,
-          fragment: T.nilable(String),
-          scheme: String,
-          load_path_entry: T.nilable(String),
-        ).returns(URI::Generic)
-      end
+    class << self
+      #: (path: String, ?fragment: String?, ?scheme: String, ?load_path_entry: String?) -> URI::Generic
       def from_path(path:, fragment: nil, scheme: "file", load_path_entry: nil)
+        # This unsafe regex is the same one used in the URI::RFC2396_REGEXP class with the exception of the fact that we
+        # do not include colon as a safe character. VS Code URIs always escape colons and we need to ensure we do the
+        # same to avoid inconsistencies in our URIs, which are used to identify resources
+        unsafe_regex = %r{[^\-_.!~*'()a-zA-Z\d;/?@&=+$,\[\]]}
+
         # On Windows, if the path begins with the disk name, we need to add a leading slash to make it a valid URI
         escaped_path = if /^[A-Z]:/i.match?(path)
-          PARSER.escape("/#{path}")
+          PARSER.escape("/#{path}", unsafe_regex)
         elsif path.start_with?("//?/")
           # Some paths on Windows start with "//?/". This is a special prefix that allows for long file paths
-          PARSER.escape(path.delete_prefix("//?"))
+          PARSER.escape(path.delete_prefix("//?"), unsafe_regex)
         else
-          PARSER.escape(path)
+          PARSER.escape(path, unsafe_regex)
         end
 
         uri = build(scheme: scheme, path: escaped_path, fragment: fragment)
@@ -42,10 +40,10 @@ module URI
       end
     end
 
-    sig { returns(T.nilable(String)) }
+    #: String?
     attr_accessor :require_path
 
-    sig { params(load_path_entry: String).void }
+    #: (String load_path_entry) -> void
     def add_require_path_from_load_entry(load_path_entry)
       path = to_standardized_path
       return unless path
@@ -53,7 +51,7 @@ module URI
       self.require_path = path.delete_prefix("#{load_path_entry}/").delete_suffix(".rb")
     end
 
-    sig { returns(T.nilable(String)) }
+    #: -> String?
     def to_standardized_path
       parsed_path = path
       return unless parsed_path

data/lib/ruby_indexer/lib/ruby_indexer/visibility_scope.rb

@@ -5,29 +5,25 @@ module RubyIndexer
   # Represents the visibility scope in a Ruby namespace. This keeps track of whether methods are in a public, private or
   # protected section, and whether they are module functions.
   class VisibilityScope
-    extend T::Sig
-
     class << self
-      extend T::Sig
-
-      sig { returns(T.attached_class) }
+      #: -> instance
       def module_function_scope
         new(module_func: true, visibility: Entry::Visibility::PRIVATE)
       end
 
-      sig { returns(T.attached_class) }
+      #: -> instance
       def public_scope
         new
       end
     end
 
-    sig { returns(Entry::Visibility) }
+    #: Entry::Visibility
     attr_reader :visibility
 
-    sig { returns(T::Boolean) }
+    #: bool
     attr_reader :module_func
 
-    sig { params(visibility: Entry::Visibility, module_func: T::Boolean).void }
+    #: (?visibility: Entry::Visibility, ?module_func: bool) -> void
     def initialize(visibility: Entry::Visibility::PUBLIC, module_func: false)
       @visibility = visibility
       @module_func = module_func

data/lib/ruby_indexer/test/classes_and_modules_test.rb

@@ -666,5 +666,80 @@ module RubyIndexer
       method = @index["baz"]&.first
       assert_equal("Foo::Bar::<Class:Bar>", method.owner.name)
     end
+
+    def test_lazy_comments_with_spaces_are_properly_attributed
+      path = File.join(Dir.pwd, "lib", "foo.rb")
+      source =  <<~RUBY
+        require "whatever"
+
+        # These comments belong to the declaration below
+        # They have to be associated with it
+
+        class Foo
+        end
+      RUBY
+      File.write(path, source)
+      @index.index_single(URI::Generic.from_path(path: path), source, collect_comments: false)
+
+      entry = @index["Foo"].first
+
+      begin
+        assert_equal(<<~COMMENTS.chomp, entry.comments)
+          These comments belong to the declaration below
+          They have to be associated with it
+        COMMENTS
+      ensure
+        FileUtils.rm(path)
+      end
+    end
+
+    def test_lazy_comments_with_no_spaces_are_properly_attributed
+      path = File.join(Dir.pwd, "lib", "foo.rb")
+      source = <<~RUBY
+        require "whatever"
+
+        # These comments belong to the declaration below
+        # They have to be associated with it
+        class Foo
+        end
+      RUBY
+      File.write(path, source)
+      @index.index_single(URI::Generic.from_path(path: path), source, collect_comments: false)
+
+      entry = @index["Foo"].first
+
+      begin
+        assert_equal(<<~COMMENTS.chomp, entry.comments)
+          These comments belong to the declaration below
+          They have to be associated with it
+        COMMENTS
+      ensure
+        FileUtils.rm(path)
+      end
+    end
+
+    def test_lazy_comments_with_two_extra_spaces_are_properly_ignored
+      path = File.join(Dir.pwd, "lib", "foo.rb")
+      source = <<~RUBY
+        require "whatever"
+
+        # These comments don't belong to the declaration below
+        # They will not be associated with it
+
+
+        class Foo
+        end
+      RUBY
+      File.write(path, source)
+      @index.index_single(URI::Generic.from_path(path: path), source, collect_comments: false)
+
+      entry = @index["Foo"].first
+
+      begin
+        assert_empty(entry.comments)
+      ensure
+        FileUtils.rm(path)
+      end
+    end
   end
 end

data/lib/ruby_indexer/test/configuration_test.rb

@@ -12,7 +12,7 @@ module RubyIndexer
     end
 
     def test_load_configuration_executes_configure_block
-      @config.apply_config({ "excluded_patterns" => ["**/fixtures/**/*.rb"] })
+      @config.apply_config({ "excluded_patterns" => ["**/fixtures/**/*"] })
       uris = @config.indexable_uris
 
       bundle_path = Bundler.bundle_path.join("gems")
@@ -39,7 +39,11 @@ module RubyIndexer
         next if lazy_spec.name == "ruby-lsp"
 
         spec = Gem::Specification.find_by_name(lazy_spec.name)
-        assert(uris.none? { |uri| uri.full_path.start_with?("#{spec.full_gem_path}/test/") })
+
+        test_uris = uris.select do |uri|
+          File.fnmatch?(File.join(spec.full_gem_path, "test/**/*"), uri.full_path, File::Constants::FNM_PATHNAME)
+        end
+        assert_empty(test_uris)
       rescue Gem::MissingSpecError
         # Transitive dependencies might be missing when running tests on Windows
       end
@@ -143,17 +147,26 @@ module RubyIndexer
         uris = @config.indexable_uris
         assert(uris.none? { |uri| uri.full_path.start_with?(File.join(dir, "ignore")) })
 
+        # The regular default gem path is ~/.rubies/3.4.1/lib/ruby/3.4.0
+        # The alternative default gem path is ~/.rubies/3.4.1/lib/ruby/gems/3.4.0
+        # Here part_1 contains ~/.rubies/3.4.1/lib/ruby/ and part_2 contains 3.4.0, so that we can turn it into the
+        # alternative path
+        part_1, part_2 = Pathname.new(RbConfig::CONFIG["rubylibdir"]).split
+        other_default_gem_dir = part_1.join("gems").join(part_2).to_s
+
         # 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
+        # - Other default gem directory
         assert(
           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"])
+            u.full_path.start_with?(RbConfig::CONFIG["rubylibdir"]) ||
+            u.full_path.start_with?(other_default_gem_dir)
           end,
         )
       end
@@ -235,5 +248,31 @@ module RubyIndexer
         end
       end
     end
+
+    def test_indexables_include_non_test_files_in_test_directories
+      # In order to linearize test parent classes and accurately detect the framework being used, then intermediate
+      # parent classes _must_ also be indexed. Otherwise, we have no way of linearizing the rest of the ancestors to
+      # determine what the test class ultimately inherits from.
+      #
+      # Therefore, we need to ensure that test files are excluded, but non test files inside test directories have to be
+      # indexed
+      FileUtils.touch("test/test_case.rb")
+
+      uris = @config.indexable_uris
+      project_paths = uris.filter_map do |uri|
+        path = uri.full_path
+        next if path.start_with?(Bundler.bundle_path.to_s) || path.start_with?(RbConfig::CONFIG["rubylibdir"])
+
+        Pathname.new(path).relative_path_from(Dir.pwd).to_s
+      end
+
+      begin
+        assert_includes(project_paths, "test/requests/support/expectations_test_runner.rb")
+        assert_includes(project_paths, "test/test_helper.rb")
+        assert_includes(project_paths, "test/test_case.rb")
+      ensure
+        FileUtils.rm("test/test_case.rb")
+      end
+    end
   end
 end

data/lib/ruby_indexer/test/index_test.rb

@@ -2161,5 +2161,26 @@ module RubyIndexer
 
       assert_equal("@@hello", candidates.first&.name)
     end
+
+    def test_actual_nesting
+      assert_equal(["Foo"], Index.actual_nesting([], "Foo"))
+      assert_equal(["TopLevel", "Foo"], Index.actual_nesting(["First", "::TopLevel"], "Foo"))
+      assert_equal(["TopLevel", "Another", "Foo"], Index.actual_nesting(["::TopLevel", "Another"], "Foo"))
+      assert_equal(["TopLevel"], Index.actual_nesting(["First", "::TopLevel"], nil))
+    end
+
+    def test_constant_name
+      node = Prism.parse("class var::Foo; end").value.statements.body.first.constant_path
+      assert_nil(Index.constant_name(node))
+
+      node = Prism.parse("class ; end").value.statements.body.first.constant_path
+      assert_nil(Index.constant_name(node))
+
+      node = Prism.parse("class method_call; end").value.statements.body.first.constant_path
+      assert_nil(Index.constant_name(node))
+
+      node = Prism.parse("class Foo; end").value.statements.body.first.constant_path
+      assert_equal("Foo", Index.constant_name(node))
+    end
   end
 end

data/lib/ruby_indexer/test/method_test.rb

@@ -924,16 +924,42 @@ module RubyIndexer
       RUBY
     end
 
+    def test_changing_visibility_post_definition
+      index(<<~RUBY)
+        class Foo
+          def bar; end
+          private :bar
+
+          def baz; end
+          protected :baz
+
+          private
+          def qux; end
+
+          public :qux
+        end
+      RUBY
+
+      entry = T.must(@index["bar"].first)
+      assert_predicate(entry, :private?)
+
+      entry = T.must(@index["baz"].first)
+      assert_predicate(entry, :protected?)
+
+      entry = T.must(@index["qux"].first)
+      assert_predicate(entry, :public?)
+    end
+
     private
 
-    sig { params(entry: Entry::Method, call_string: String).void }
+    #: (Entry::Method entry, String call_string) -> void
     def assert_signature_matches(entry, call_string)
       sig = T.must(entry.signatures.first)
       arguments = parse_prism_args(call_string)
       assert(sig.matches?(arguments), "Expected #{call_string} to match #{entry.name}#{entry.decorated_parameters}")
     end
 
-    sig { params(entry: Entry::Method, call_string: String).void }
+    #: (Entry::Method entry, String call_string) -> void
     def refute_signature_matches(entry, call_string)
       sig = T.must(entry.signatures.first)
       arguments = parse_prism_args(call_string)

data/lib/ruby_indexer/test/rbs_indexer_test.rb

@@ -359,7 +359,7 @@ module RubyIndexer
       assert_equal("all?", entry.old_name)
       assert_equal("Array", entry.owner.name)
       assert(entry.file_path.end_with?("core/array.rbs"))
-      assert_includes(entry.comments, "Returns `true` if any element of `self` meets a given criterion.")
+      refute_empty(entry.comments)
     end
 
     def test_indexing_untyped_functions

data/lib/ruby_indexer/test/uri_test.rb

@@ -12,12 +12,12 @@ module RubyIndexer
 
     def test_from_path_on_windows
       uri = URI::Generic.from_path(path: "C:/some/windows/path/to/file.rb")
-      assert_equal("/C:/some/windows/path/to/file.rb", uri.path)
+      assert_equal("/C%3A/some/windows/path/to/file.rb", uri.path)
     end
 
     def test_from_path_on_windows_with_lowercase_drive
       uri = URI::Generic.from_path(path: "c:/some/windows/path/to/file.rb")
-      assert_equal("/c:/some/windows/path/to/file.rb", uri.path)
+      assert_equal("/c%3A/some/windows/path/to/file.rb", uri.path)
     end
 
     def test_to_standardized_path_on_unix
@@ -68,5 +68,18 @@ module RubyIndexer
       uri.add_require_path_from_load_entry("/some/unix/path")
       assert_equal("to/file", uri.require_path)
     end
+
+    def test_from_path_escapes_colon_characters
+      uri = URI::Generic.from_path(path: "c:/some/windows/path with/spaces/file.rb")
+      assert_equal("c:/some/windows/path with/spaces/file.rb", uri.to_standardized_path)
+      assert_equal("file:///c%3A/some/windows/path%20with/spaces/file.rb", uri.to_s)
+    end
+
+    def test_from_path_with_unicode_characters
+      path = "/path/with/unicode/文件.rb"
+      uri = URI::Generic.from_path(path: path)
+      assert_equal(path, uri.to_standardized_path)
+      assert_equal("file:///path/with/unicode/%E6%96%87%E4%BB%B6.rb", uri.to_s)
+    end
   end
 end

data/lib/ruby_lsp/addon.rb

@@ -25,42 +25,34 @@ module RubyLsp
 
     abstract!
 
-    @addons = T.let([], T::Array[Addon])
-    @addon_classes = T.let([], T::Array[T.class_of(Addon)])
+    @addons = [] #: Array[Addon]
+    @addon_classes = [] #: Array[singleton(Addon)]
     # Add-on instances that have declared a handler to accept file watcher events
-    @file_watcher_addons = T.let([], T::Array[Addon])
+    @file_watcher_addons = [] #: Array[Addon]
 
     AddonNotFoundError = Class.new(StandardError)
 
     class IncompatibleApiError < StandardError; end
 
     class << self
-      extend T::Sig
-
-      sig { returns(T::Array[Addon]) }
+      #: Array[Addon]
       attr_accessor :addons
 
-      sig { returns(T::Array[Addon]) }
+      #: Array[Addon]
       attr_accessor :file_watcher_addons
 
-      sig { returns(T::Array[T.class_of(Addon)]) }
+      #: Array[singleton(Addon)]
       attr_reader :addon_classes
 
       # Automatically track and instantiate add-on classes
-      sig { params(child_class: T.class_of(Addon)).void }
+      #: (singleton(Addon) child_class) -> void
       def inherited(child_class)
         addon_classes << child_class
         super
       end
 
       # Discovers and loads all add-ons. Returns a list of errors when trying to require add-ons
-      sig do
-        params(
-          global_state: GlobalState,
-          outgoing_queue: Thread::Queue,
-          include_project_addons: T::Boolean,
-        ).returns(T::Array[StandardError])
-      end
+      #: (GlobalState global_state, Thread::Queue outgoing_queue, ?include_project_addons: bool) -> Array[StandardError]
       def load_addons(global_state, outgoing_queue, include_project_addons: true)
         # Require all add-ons entry points, which should be placed under
         # `some_gem/lib/ruby_lsp/your_gem_name/addon.rb` or in the workspace under
@@ -98,7 +90,7 @@ module RubyLsp
       end
 
       # Unloads all add-ons. Only intended to be invoked once when shutting down the Ruby LSP server
-      sig { void }
+      #: -> void
       def unload_addons
         @addons.each(&:deactivate)
         @addons.clear
@@ -112,7 +104,7 @@ module RubyLsp
       # Important: if the add-on is not found, AddonNotFoundError will be raised. If the add-on is found, but its
       # current version does not satisfy the given version constraint, then IncompatibleApiError will be raised. It is
       # the responsibility of the add-ons using this API to handle these errors appropriately.
-      sig { params(addon_name: String, version_constraints: String).returns(Addon) }
+      #: (String addon_name, *String version_constraints) -> Addon
       def get(addon_name, *version_constraints)
         if version_constraints.empty?
           raise IncompatibleApiError, "Must specify version constraints when accessing other add-ons"
@@ -144,7 +136,7 @@ module RubyLsp
       #   end
       # end
       # ```
-      sig { params(version_constraints: String).void }
+      #: (*String version_constraints) -> void
       def depend_on_ruby_lsp!(*version_constraints)
         version_object = Gem::Version.new(RubyLsp::VERSION)
 
@@ -155,23 +147,23 @@ module RubyLsp
       end
     end
 
-    sig { void }
+    #: -> void
     def initialize
-      @errors = T.let([], T::Array[StandardError])
+      @errors = [] #: Array[StandardError]
     end
 
-    sig { params(error: StandardError).returns(T.self_type) }
+    #: (StandardError error) -> self
     def add_error(error)
       @errors << error
       self
     end
 
-    sig { returns(T::Boolean) }
+    #: -> bool
     def error?
       @errors.any?
     end
 
-    sig { returns(String) }
+    #: -> String
     def formatted_errors
       <<~ERRORS
         #{name}:
@@ -179,7 +171,7 @@ module RubyLsp
       ERRORS
     end
 
-    sig { returns(String) }
+    #: -> String
     def errors_details
       @errors.map(&:full_message).join("\n\n")
     end
@@ -207,69 +199,50 @@ module RubyLsp
     # original request so that the response is delegated to the correct add-on and must override this method to handle
     # the response
     # https://microsoft.github.io/language-server-protocol/specification#window_showMessageRequest
-    sig { overridable.params(title: String).void }
+    # @overridable
+    #: (String title) -> void
     def handle_window_show_message_response(title); end
 
     # Creates a new CodeLens listener. This method is invoked on every CodeLens request
-    sig do
-      overridable.params(
-        response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens],
-        uri: URI::Generic,
-        dispatcher: Prism::Dispatcher,
-      ).void
-    end
+    # @overridable
+    #: (ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens] response_builder, URI::Generic uri, Prism::Dispatcher dispatcher) -> void
     def create_code_lens_listener(response_builder, uri, dispatcher); end
 
     # Creates a new Hover listener. This method is invoked on every Hover request
-    sig do
-      overridable.params(
-        response_builder: ResponseBuilders::Hover,
-        node_context: NodeContext,
-        dispatcher: Prism::Dispatcher,
-      ).void
-    end
+    # @overridable
+    #: (ResponseBuilders::Hover response_builder, NodeContext node_context, Prism::Dispatcher dispatcher) -> void
     def create_hover_listener(response_builder, node_context, dispatcher); end
 
     # Creates a new DocumentSymbol listener. This method is invoked on every DocumentSymbol request
-    sig do
-      overridable.params(
-        response_builder: ResponseBuilders::DocumentSymbol,
-        dispatcher: Prism::Dispatcher,
-      ).void
-    end
+    # @overridable
+    #: (ResponseBuilders::DocumentSymbol response_builder, Prism::Dispatcher dispatcher) -> void
     def create_document_symbol_listener(response_builder, dispatcher); end
 
-    sig do
-      overridable.params(
-        response_builder: ResponseBuilders::SemanticHighlighting,
-        dispatcher: Prism::Dispatcher,
-      ).void
-    end
+    # @overridable
+    #: (ResponseBuilders::SemanticHighlighting response_builder, Prism::Dispatcher dispatcher) -> void
     def create_semantic_highlighting_listener(response_builder, dispatcher); end
 
     # Creates a new Definition listener. This method is invoked on every Definition request
-    sig do
-      overridable.params(
-        response_builder: ResponseBuilders::CollectionResponseBuilder[T.any(
-          Interface::Location,
-          Interface::LocationLink,
-        )],
-        uri: URI::Generic,
-        node_context: NodeContext,
-        dispatcher: Prism::Dispatcher,
-      ).void
-    end
+    # @overridable
+    #: (ResponseBuilders::CollectionResponseBuilder[(Interface::Location | Interface::LocationLink)] response_builder, URI::Generic uri, NodeContext node_context, Prism::Dispatcher dispatcher) -> void
     def create_definition_listener(response_builder, uri, node_context, dispatcher); end
 
     # Creates a new Completion listener. This method is invoked on every Completion request
-    sig do
-      overridable.params(
-        response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem],
-        node_context: NodeContext,
-        dispatcher: Prism::Dispatcher,
-        uri: URI::Generic,
-      ).void
-    end
+    # @overridable
+    #: (ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem] response_builder, NodeContext node_context, Prism::Dispatcher dispatcher, URI::Generic uri) -> void
     def create_completion_listener(response_builder, node_context, dispatcher, uri); end
+
+    # Creates a new Discover Tests listener. This method is invoked on every DiscoverTests request
+    # @overridable
+    #: (ResponseBuilders::TestCollection response_builder, Prism::Dispatcher dispatcher, URI::Generic uri) -> void
+    def create_discover_tests_listener(response_builder, dispatcher, uri); end
+
+    # Resolves the minimal set of commands required to execute the requested tests. Add-ons are responsible for only
+    # handling items related to the framework they add support for and have discovered themselves
+    # @overridable
+    #: (Array[Hash[Symbol, untyped]]) -> Array[String]
+    def resolve_test_commands(items)
+      []
+    end
   end
 end