ruby-lsp 0.23.11 → 0.23.12

data/lib/ruby_lsp/response_builders/document_symbol.rb

@@ -4,23 +4,19 @@
 module RubyLsp
   module ResponseBuilders
     class DocumentSymbol < ResponseBuilder
-      extend T::Sig
-
       ResponseType = type_member { { fixed: T::Array[Interface::DocumentSymbol] } }
 
       class SymbolHierarchyRoot
-        extend T::Sig
-
-        sig { returns(T::Array[Interface::DocumentSymbol]) }
+        #: Array[Interface::DocumentSymbol]
         attr_reader :children
 
-        sig { void }
+        #: -> void
         def initialize
           @children = T.let([], T::Array[Interface::DocumentSymbol])
         end
       end
 
-      sig { void }
+      #: -> void
       def initialize
         super
         @stack = T.let(
@@ -29,26 +25,27 @@ module RubyLsp
         )
       end
 
-      sig { params(symbol: Interface::DocumentSymbol).void }
+      #: (Interface::DocumentSymbol symbol) -> void
       def push(symbol)
         @stack << symbol
       end
 
       alias_method(:<<, :push)
 
-      sig { returns(T.nilable(Interface::DocumentSymbol)) }
+      #: -> Interface::DocumentSymbol?
       def pop
         if @stack.size > 1
           T.cast(@stack.pop, Interface::DocumentSymbol)
         end
       end
 
-      sig { returns(T.any(SymbolHierarchyRoot, Interface::DocumentSymbol)) }
+      #: -> (SymbolHierarchyRoot | Interface::DocumentSymbol)
       def last
         T.must(@stack.last)
       end
 
-      sig { override.returns(T::Array[Interface::DocumentSymbol]) }
+      # @override
+      #: -> Array[Interface::DocumentSymbol]
       def response
         T.must(@stack.first).children
       end

data/lib/ruby_lsp/response_builders/hover.rb

@@ -4,12 +4,11 @@
 module RubyLsp
   module ResponseBuilders
     class Hover < ResponseBuilder
-      extend T::Sig
       extend T::Generic
 
       ResponseType = type_member { { fixed: String } }
 
-      sig { void }
+      #: -> void
       def initialize
         super
 
@@ -23,7 +22,7 @@ module RubyLsp
         )
       end
 
-      sig { params(content: String, category: Symbol).void }
+      #: (String content, category: Symbol) -> void
       def push(content, category:)
         hover_content = @response[category]
         if hover_content
@@ -31,12 +30,13 @@ module RubyLsp
         end
       end
 
-      sig { returns(T::Boolean) }
+      #: -> bool
       def empty?
         @response.values.all?(&:empty?)
       end
 
-      sig { override.returns(ResponseType) }
+      # @override
+      #: -> ResponseType
       def response
         result = T.must(@response[:title])
         result << "\n" << @response[:links] if @response[:links]

data/lib/ruby_lsp/response_builders/response_builder.rb

@@ -4,8 +4,8 @@
 module RubyLsp
   module ResponseBuilders
     class ResponseBuilder
-      extend T::Sig
       extend T::Generic
+      extend T::Sig
 
       abstract!
 

data/lib/ruby_lsp/response_builders/semantic_highlighting.rb

@@ -6,8 +6,6 @@ module RubyLsp
     class SemanticHighlighting < ResponseBuilder
       class UndefinedTokenType < StandardError; end
 
-      extend T::Sig
-
       TOKEN_TYPES = T.let(
         {
           namespace: 0,
@@ -55,19 +53,14 @@ module RubyLsp
 
       ResponseType = type_member { { fixed: Interface::SemanticTokens } }
 
-      sig do
-        params(code_units_cache: T.any(
-          T.proc.params(arg0: Integer).returns(Integer),
-          Prism::CodeUnitsCache,
-        )).void
-      end
+      #: ((^(Integer arg0) -> Integer | Prism::CodeUnitsCache) code_units_cache) -> void
       def initialize(code_units_cache)
         super()
         @code_units_cache = code_units_cache
         @stack = T.let([], T::Array[SemanticToken])
       end
 
-      sig { params(location: Prism::Location, type: Symbol, modifiers: T::Array[Symbol]).void }
+      #: (Prism::Location location, Symbol type, ?Array[Symbol] modifiers) -> void
       def add_token(location, type, modifiers = [])
         end_code_unit = location.cached_end_code_units_offset(@code_units_cache)
         length = end_code_unit - location.cached_start_code_units_offset(@code_units_cache)
@@ -83,7 +76,7 @@ module RubyLsp
         )
       end
 
-      sig { params(location: Prism::Location).returns(T::Boolean) }
+      #: (Prism::Location location) -> bool
       def last_token_matches?(location)
         token = @stack.last
         return false unless token
@@ -92,43 +85,34 @@ module RubyLsp
           token.start_code_unit_column == location.cached_start_code_units_column(@code_units_cache)
       end
 
-      sig { returns(T.nilable(SemanticToken)) }
+      #: -> SemanticToken?
       def last
         @stack.last
       end
 
-      sig { override.returns(T::Array[SemanticToken]) }
+      # @override
+      #: -> Array[SemanticToken]
       def response
         @stack
       end
 
       class SemanticToken
-        extend T::Sig
-
-        sig { returns(Integer) }
+        #: Integer
         attr_reader :start_line
 
-        sig { returns(Integer) }
+        #: Integer
         attr_reader :start_code_unit_column
 
-        sig { returns(Integer) }
+        #: Integer
         attr_reader :length
 
-        sig { returns(Integer) }
+        #: Integer
         attr_reader :type
 
-        sig { returns(T::Array[Integer]) }
+        #: Array[Integer]
         attr_reader :modifier
 
-        sig do
-          params(
-            start_line: Integer,
-            start_code_unit_column: Integer,
-            length: Integer,
-            type: Integer,
-            modifier: T::Array[Integer],
-          ).void
-        end
+        #: (start_line: Integer, start_code_unit_column: Integer, length: Integer, type: Integer, modifier: Array[Integer]) -> void
         def initialize(start_line:, start_code_unit_column:, length:, type:, modifier:)
           @start_line = start_line
           @start_code_unit_column = start_code_unit_column
@@ -137,7 +121,7 @@ module RubyLsp
           @modifier = modifier
         end
 
-        sig { params(type_symbol: Symbol).void }
+        #: (Symbol type_symbol) -> void
         def replace_type(type_symbol)
           type_int = TOKEN_TYPES[type_symbol]
           raise UndefinedTokenType, "Undefined token type: #{type_symbol}" unless type_int
@@ -145,7 +129,7 @@ module RubyLsp
           @type = type_int
         end
 
-        sig { params(modifier_symbols: T::Array[Symbol]).void }
+        #: (Array[Symbol] modifier_symbols) -> void
         def replace_modifier(modifier_symbols)
           @modifier = modifier_symbols.filter_map do |modifier_symbol|
             modifier_index = TOKEN_MODIFIERS[modifier_symbol]
@@ -157,19 +141,13 @@ module RubyLsp
       end
 
       class SemanticTokenEncoder
-        extend T::Sig
-
-        sig { void }
+        #: -> void
         def initialize
           @current_row = T.let(0, Integer)
           @current_column = T.let(0, Integer)
         end
 
-        sig do
-          params(
-            tokens: T::Array[SemanticToken],
-          ).returns(T::Array[Integer])
-        end
+        #: (Array[SemanticToken] tokens) -> Array[Integer]
         def encode(tokens)
           sorted_tokens = tokens.sort_by.with_index do |token, index|
             # Enumerable#sort_by is not deterministic when the compared values are equal.
@@ -194,7 +172,7 @@ module RubyLsp
 
         # For more information on how each number is calculated, read:
         # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_semanticTokens
-        sig { params(token: SemanticToken).returns(T::Array[Integer]) }
+        #: (SemanticToken token) -> Array[Integer]
         def compute_delta(token)
           row = token.start_line - 1
           column = token.start_code_unit_column
@@ -216,7 +194,7 @@ module RubyLsp
         # For example, [:default_library] will be encoded as
         # 0b1000000000, as :default_library is the 10th bit according
         # to the token modifiers index map.
-        sig { params(modifiers: T::Array[Integer]).returns(Integer) }
+        #: (Array[Integer] modifiers) -> Integer
         def encode_modifiers(modifiers)
           modifiers.inject(0) do |encoded_modifiers, modifier|
             encoded_modifiers | (1 << modifier)

data/lib/ruby_lsp/response_builders/signature_help.rb

@@ -4,22 +4,21 @@
 module RubyLsp
   module ResponseBuilders
     class SignatureHelp < ResponseBuilder
-      extend T::Sig
-
       ResponseType = type_member { { fixed: T.nilable(Interface::SignatureHelp) } }
 
-      sig { void }
+      #: -> void
       def initialize
         super
         @signature_help = T.let(nil, ResponseType)
       end
 
-      sig { params(signature_help: ResponseType).void }
+      #: (ResponseType signature_help) -> void
       def replace(signature_help)
         @signature_help = signature_help
       end
 
-      sig { override.returns(ResponseType) }
+      # @override
+      #: -> ResponseType
       def response
         @signature_help
       end

data/lib/ruby_lsp/response_builders/test_collection.rb

@@ -4,32 +4,28 @@
 module RubyLsp
   module ResponseBuilders
     class TestCollection < ResponseBuilder
-      class DuplicateIdError < StandardError; end
-
-      extend T::Sig
       extend T::Generic
 
       ResponseType = type_member { { fixed: Requests::Support::TestItem } }
 
-      sig { void }
+      #: -> void
       def initialize
         super
         @items = T.let({}, T::Hash[String, ResponseType])
       end
 
-      sig { params(item: ResponseType).void }
+      #: (ResponseType item) -> void
       def add(item)
-        raise DuplicateIdError, "TestItem ID is already in use" if @items.key?(item.id)
-
         @items[item.id] = item
       end
 
-      sig { params(id: String).returns(T.nilable(ResponseType)) }
+      #: (String id) -> ResponseType?
       def [](id)
         @items[id]
       end
 
-      sig { override.returns(T::Array[ResponseType]) }
+      # @override
+      #: -> Array[ResponseType]
       def response
         @items.values
       end

data/lib/ruby_lsp/ruby_document.rb

@@ -3,7 +3,6 @@
 
 module RubyLsp
   class RubyDocument < Document
-    extend T::Sig
     extend T::Generic
 
     ParseResultType = type_member { { fixed: Prism::ParseResult } }
@@ -35,19 +34,7 @@ module RubyLsp
     end
 
     class << self
-      extend T::Sig
-
-      sig do
-        params(
-          node: Prism::Node,
-          char_position: Integer,
-          code_units_cache: T.any(
-            T.proc.params(arg0: Integer).returns(Integer),
-            Prism::CodeUnitsCache,
-          ),
-          node_types: T::Array[T.class_of(Prism::Node)],
-        ).returns(NodeContext)
-      end
+      #: (Prism::Node node, Integer char_position, code_units_cache: (^(Integer arg0) -> Integer | Prism::CodeUnitsCache), ?node_types: Array[singleton(Prism::Node)]) -> NodeContext
       def locate(node, char_position, code_units_cache:, node_types: [])
         queue = T.let(node.child_nodes.compact, T::Array[T.nilable(Prism::Node)])
         closest = node
@@ -150,15 +137,10 @@ module RubyLsp
       end
     end
 
-    sig do
-      returns(T.any(
-        T.proc.params(arg0: Integer).returns(Integer),
-        Prism::CodeUnitsCache,
-      ))
-    end
+    #: (^(Integer arg0) -> Integer | Prism::CodeUnitsCache)
     attr_reader :code_units_cache
 
-    sig { params(source: String, version: Integer, uri: URI::Generic, global_state: GlobalState).void }
+    #: (source: String, version: Integer, uri: URI::Generic, global_state: GlobalState) -> void
     def initialize(source:, version:, uri:, global_state:)
       super
       @code_units_cache = T.let(@parse_result.code_units_cache(@encoding), T.any(
@@ -167,7 +149,8 @@ module RubyLsp
       ))
     end
 
-    sig { override.returns(T::Boolean) }
+    # @override
+    #: -> bool
     def parse!
       return false unless @needs_parsing
 
@@ -177,17 +160,19 @@ module RubyLsp
       true
     end
 
-    sig { override.returns(T::Boolean) }
+    # @override
+    #: -> bool
     def syntax_error?
       @parse_result.failure?
     end
 
-    sig { override.returns(LanguageId) }
+    # @override
+    #: -> LanguageId
     def language_id
       LanguageId::Ruby
     end
 
-    sig { returns(SorbetLevel) }
+    #: -> SorbetLevel
     def sorbet_level
       sigil = parse_result.magic_comments.find do |comment|
         comment.key == "typed"
@@ -207,12 +192,7 @@ module RubyLsp
       end
     end
 
-    sig do
-      params(
-        range: T::Hash[Symbol, T.untyped],
-        node_types: T::Array[T.class_of(Prism::Node)],
-      ).returns(T.nilable(Prism::Node))
-    end
+    #: (Hash[Symbol, untyped] range, ?node_types: Array[singleton(Prism::Node)]) -> Prism::Node?
     def locate_first_within_range(range, node_types: [])
       start_position, end_position = find_index_by_position(range[:start], range[:end])
 
@@ -240,12 +220,7 @@ module RubyLsp
       end
     end
 
-    sig do
-      params(
-        position: T::Hash[Symbol, T.untyped],
-        node_types: T::Array[T.class_of(Prism::Node)],
-      ).returns(NodeContext)
-    end
+    #: (Hash[Symbol, untyped] position, ?node_types: Array[singleton(Prism::Node)]) -> NodeContext
     def locate_node(position, node_types: [])
       char_position, _ = find_index_by_position(position)
 
@@ -257,7 +232,7 @@ module RubyLsp
       )
     end
 
-    sig { returns(T::Boolean) }
+    #: -> bool
     def should_index?
       # This method controls when we should index documents. If there's no recent edit and the document has just been
       # opened, we need to index it
@@ -268,7 +243,7 @@ module RubyLsp
 
     private
 
-    sig { returns(T::Boolean) }
+    #: -> bool
     def last_edit_may_change_declarations?
       case @last_edit
       when Delete
@@ -282,7 +257,7 @@ module RubyLsp
       end
     end
 
-    sig { params(position: T::Hash[Symbol, Integer]).returns(T::Boolean) }
+    #: (Hash[Symbol, Integer] position) -> bool
     def position_may_impact_declarations?(position)
       node_context = locate_node(position)
       node_at_edit = node_context.node

data/lib/ruby_lsp/ruby_lsp_reporter_plugin.rb

@@ -0,0 +1,106 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "test_reporter"
+require "ruby_indexer/lib/ruby_indexer/uri"
+
+require "minitest"
+
+module Minitest
+  module Reporters
+    class RubyLspReporter < ::Minitest::AbstractReporter
+      class << self
+        #: (Hash[untyped, untyped]) -> void
+        def minitest_plugin_init(_options)
+          Minitest.reporter.reporters = [RubyLspReporter.new]
+        end
+      end
+
+      #: (singleton(Minitest::Test) test_class, String method_name) -> void
+      def prerecord(test_class, method_name)
+        uri = uri_from_test_class(test_class, method_name)
+        return unless uri
+
+        RubyLsp::TestReporter.start_test(
+          id: "#{test_class.name}##{method_name}",
+          uri: uri,
+        )
+      end
+
+      #: (Minitest::Result result) -> void
+      def record(result)
+        if result.error?
+          record_error(result)
+        elsif result.passed?
+          record_pass(result)
+        elsif result.skipped?
+          record_skip(result)
+        elsif result.failure
+          record_fail(result)
+        end
+      end
+
+      private
+
+      #: (Minitest::Result result) -> void
+      def record_pass(result)
+        RubyLsp::TestReporter.record_pass(
+          id: id_from_result(result),
+          uri: uri_from_result(result),
+        )
+      end
+
+      #: (Minitest::Result result) -> void
+      def record_skip(result)
+        RubyLsp::TestReporter.record_skip(
+          id: id_from_result(result),
+          message: result.failure.message,
+          uri: uri_from_result(result),
+        )
+      end
+
+      #: (Minitest::Result result) -> void
+      def record_fail(result)
+        RubyLsp::TestReporter.record_fail(
+          id: id_from_result(result),
+          message: result.failure.message,
+          uri: uri_from_result(result),
+        )
+      end
+
+      #: (Minitest::Result result) -> void
+      def record_error(result)
+        RubyLsp::TestReporter.record_error(
+          id: id_from_result(result),
+          uri: uri_from_result(result),
+          message: result.failures.first.message,
+        )
+      end
+
+      #: (Minitest::Result result) -> String
+      def id_from_result(result)
+        "#{result.klass}##{result.name}"
+      end
+
+      #: (Minitest::Result result) -> URI::Generic
+      def uri_from_result(result)
+        file = result.source_location[0]
+        absolute_path = File.expand_path(file, Dir.pwd)
+        URI::Generic.from_path(path: absolute_path)
+      end
+
+      #: (singleton(Minitest::Test) test_class, String method_name) -> URI::Generic?
+      def uri_from_test_class(test_class, method_name)
+        file, _line = test_class.instance_method(method_name).source_location
+        return unless file
+
+        return if file.start_with?("(eval at ") # test is dynamically defined
+
+        absolute_path = File.expand_path(file, Dir.pwd)
+        URI::Generic.from_path(path: absolute_path)
+      end
+    end
+  end
+end
+
+Minitest.extensions << Minitest::Reporters::RubyLspReporter

data/lib/ruby_lsp/scope.rb

@@ -3,12 +3,10 @@
 
 module RubyLsp
   class Scope
-    extend T::Sig
-
-    sig { returns(T.nilable(Scope)) }
+    #: Scope?
     attr_reader :parent
 
-    sig { params(parent: T.nilable(Scope)).void }
+    #: (?Scope? parent) -> void
     def initialize(parent = nil)
       @parent = parent
 
@@ -17,12 +15,12 @@ module RubyLsp
     end
 
     # Add a new local to this scope. The types should only be `:parameter` or `:variable`
-    sig { params(name: T.any(String, Symbol), type: Symbol).void }
+    #: ((String | Symbol) name, Symbol type) -> void
     def add(name, type)
       @locals[name.to_sym] = Local.new(type)
     end
 
-    sig { params(name: T.any(String, Symbol)).returns(T.nilable(Local)) }
+    #: ((String | Symbol) name) -> Local?
     def lookup(name)
       sym = name.to_sym
       entry = @locals[sym]
@@ -33,12 +31,10 @@ module RubyLsp
     end
 
     class Local
-      extend T::Sig
-
-      sig { returns(Symbol) }
+      #: Symbol
       attr_reader :type
 
-      sig { params(type: Symbol).void }
+      #: (Symbol type) -> void
       def initialize(type)
         @type = type
       end