ruby-lsp 0.23.11 → 0.23.13

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)
+        @signature_help = 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])
+        @items = {} #: 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,38 +34,15 @@ 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)])
+        queue = node.child_nodes.compact #: Array[Prism::Node?]
         closest = node
-        parent = T.let(nil, T.nilable(Prism::Node))
-        nesting_nodes = T.let(
-          [],
-          T::Array[T.any(
-            Prism::ClassNode,
-            Prism::ModuleNode,
-            Prism::SingletonClassNode,
-            Prism::DefNode,
-            Prism::BlockNode,
-            Prism::LambdaNode,
-            Prism::ProgramNode,
-          )],
-        )
+        parent = nil #: Prism::Node?
+        nesting_nodes = [] #: Array[(Prism::ClassNode | Prism::ModuleNode | Prism::SingletonClassNode | Prism::DefNode | Prism::BlockNode | Prism::LambdaNode | Prism::ProgramNode)] # rubocop:disable Layout/LineLength
 
         nesting_nodes << node if node.is_a?(Prism::ProgramNode)
-        call_node = T.let(nil, T.nilable(Prism::CallNode))
+        call_node = nil #: Prism::CallNode?
 
         until queue.empty?
           candidate = queue.shift
@@ -150,24 +126,18 @@ 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(
-        T.proc.params(arg0: Integer).returns(Integer),
-        Prism::CodeUnitsCache,
-      ))
+      @code_units_cache = @parse_result
+        .code_units_cache(@encoding) #: (^(Integer arg0) -> Integer | Prism::CodeUnitsCache)
     end
 
-    sig { override.returns(T::Boolean) }
+    # @override
+    #: -> bool
     def parse!
       return false unless @needs_parsing
 
@@ -177,17 +147,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,17 +179,12 @@ 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])
 
       desired_range = (start_position...end_position)
-      queue = T.let(@parse_result.value.child_nodes.compact, T::Array[T.nilable(Prism::Node)])
+      queue = @parse_result.value.child_nodes.compact #: Array[Prism::Node?]
 
       until queue.empty?
         candidate = queue.shift
@@ -240,12 +207,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 +219,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 +230,7 @@ module RubyLsp
 
     private
 
-    sig { returns(T::Boolean) }
+    #: -> bool
     def last_edit_may_change_declarations?
       case @last_edit
       when Delete
@@ -282,7 +244,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,109 @@
+# typed: strict
+# frozen_string_literal: true
+
+begin
+  require "minitest"
+rescue LoadError
+  return
+end
+
+require_relative "test_reporter"
+require "ruby_indexer/lib/ruby_indexer/uri"
+
+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),
+          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,26 +3,24 @@
 
 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
 
       # A hash of name => type
-      @locals = T.let({}, T::Hash[Symbol, Local])
+      @locals = {} #: Hash[Symbol, Local]
     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