ruby-lsp 0.23.11 → 0.23.17

data/lib/ruby_lsp/test_reporters/minitest_reporter.rb

@@ -0,0 +1,105 @@
+# typed: strict
+# frozen_string_literal: true
+
+begin
+  require "minitest"
+rescue LoadError
+  return
+end
+
+require_relative "lsp_reporter"
+require "ruby_indexer/lib/ruby_indexer/uri"
+
+module RubyLsp
+  # An override of the default progress reporter in Minitest to add color to the output
+  class ProgressReporterWithColor < Minitest::ProgressReporter
+    #: (Minitest::Result) -> void
+    def record(result)
+      color = if result.error?
+        "\e[31m" # red
+      elsif result.passed?
+        "\e[32m" # green
+      elsif result.skipped?
+        "\e[33m" # yellow
+      elsif result.failure
+        "\e[31m" # red
+      else
+        "\e[0m" # no color
+      end
+
+      io.print("#{color}#{result.result_code}\e[0m") # Reset color after printing
+    end
+  end
+
+  class MinitestReporter < Minitest::AbstractReporter
+    class << self
+      #: (Hash[untyped, untyped]) -> void
+      def minitest_plugin_init(_options)
+        # Remove the original progress reporter, so that we replace it with our own. We only do this if no other
+        # reporters were included by the application itself to avoid double reporting
+        reporters = Minitest.reporter.reporters
+
+        if reporters.all? { |r| r.is_a?(Minitest::ProgressReporter) || r.is_a?(Minitest::SummaryReporter) }
+          reporters.delete_if { |r| r.is_a?(Minitest::ProgressReporter) }
+          reporters << ProgressReporterWithColor.new
+        end
+
+        # Add the JSON RPC reporter
+        reporters << MinitestReporter.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
+
+      LspReporter.instance.start_test(id: "#{test_class.name}##{method_name}", uri: uri)
+    end
+
+    #: (Minitest::Result result) -> void
+    def record(result)
+      id = "#{result.klass}##{result.name}"
+      uri = uri_from_result(result)
+
+      if result.error?
+        message = result.failures.first.message
+        LspReporter.instance.record_error(id: id, uri: uri, message: message)
+      elsif result.passed?
+        LspReporter.instance.record_pass(id: id, uri: uri)
+      elsif result.skipped?
+        LspReporter.instance.record_skip(id: id, uri: uri)
+      elsif result.failure
+        message = result.failure.message
+        LspReporter.instance.record_fail(id: id, uri: uri, message: message)
+      end
+    end
+
+    #: -> void
+    def report
+      LspReporter.instance.shutdown
+    end
+
+    private
+
+    #: (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
+
+Minitest.extensions << RubyLsp::MinitestReporter

data/lib/ruby_lsp/test_reporters/test_unit_reporter.rb

@@ -0,0 +1,94 @@
+# typed: true
+# frozen_string_literal: true
+
+begin
+  require "test/unit"
+  require "test/unit/ui/testrunner"
+  require "test/unit/ui/console/testrunner"
+rescue LoadError
+  return
+end
+
+require_relative "lsp_reporter"
+require "ruby_indexer/lib/ruby_indexer/uri"
+
+module RubyLsp
+  class TestUnitReporter < Test::Unit::UI::Console::TestRunner
+    def initialize(suite, options = {})
+      super
+      @current_uri = nil #: URI::Generic?
+      @current_test_id = nil #: String?
+    end
+
+    private
+
+    #: (::Test::Unit::TestCase test) -> void
+    def test_started(test)
+      super
+
+      current_test = test
+      @current_uri = uri_for_test(current_test)
+      return unless @current_uri
+
+      @current_test_id = "#{current_test.class.name}##{current_test.method_name}"
+      LspReporter.instance.start_test(id: @current_test_id, uri: @current_uri)
+    end
+
+    #: (::Test::Unit::TestCase test) -> void
+    def test_finished(test)
+      super
+      return unless test.passed? && @current_uri && @current_test_id
+
+      LspReporter.instance.record_pass(id: @current_test_id, uri: @current_uri)
+    end
+
+    #: (::Test::Unit::Failure | ::Test::Unit::Error | ::Test::Unit::Pending result) -> void
+    def add_fault(result)
+      super
+      return unless @current_uri && @current_test_id
+
+      case result
+      when ::Test::Unit::Failure
+        LspReporter.instance.record_fail(id: @current_test_id, message: result.message, uri: @current_uri)
+      when ::Test::Unit::Error
+        LspReporter.instance.record_error(id: @current_test_id, message: result.message, uri: @current_uri)
+      when ::Test::Unit::Pending
+        LspReporter.instance.record_skip(id: @current_test_id, uri: @current_uri)
+      end
+    end
+
+    #: (Float) -> void
+    def finished(elapsed_time)
+      LspReporter.instance.shutdown
+    end
+
+    #: (::Test::Unit::TestCase test) -> URI::Generic?
+    def uri_for_test(test)
+      location = test.method(test.method_name).source_location
+      return unless location
+
+      file, _line = location
+      return if file.start_with?("(eval at ")
+
+      absolute_path = File.expand_path(file, Dir.pwd)
+      URI::Generic.from_path(path: absolute_path)
+    end
+
+    #: -> void
+    def attach_to_mediator
+      # Events we care about
+      @mediator.add_listener(Test::Unit::TestResult::FAULT, &method(:add_fault))
+      @mediator.add_listener(Test::Unit::TestCase::STARTED_OBJECT, &method(:test_started))
+      @mediator.add_listener(Test::Unit::TestCase::FINISHED_OBJECT, &method(:test_finished))
+      @mediator.add_listener(Test::Unit::UI::TestRunnerMediator::FINISHED, &method(:finished))
+
+      # Other events needed for the console test runner to print
+      @mediator.add_listener(Test::Unit::UI::TestRunnerMediator::STARTED, &method(:started))
+      @mediator.add_listener(Test::Unit::TestSuite::STARTED_OBJECT, &method(:test_suite_started))
+      @mediator.add_listener(Test::Unit::TestSuite::FINISHED_OBJECT, &method(:test_suite_finished))
+    end
+  end
+end
+
+Test::Unit::AutoRunner.register_runner(:ruby_lsp) { |_auto_runner| RubyLsp::TestUnitReporter }
+Test::Unit::AutoRunner.default_runner = :ruby_lsp

data/lib/ruby_lsp/type_inferrer.rb

@@ -5,14 +5,12 @@ module RubyLsp
   # A minimalistic type checker to try to resolve types that can be inferred without requiring a type system or
   # annotations
   class TypeInferrer
-    extend T::Sig
-
-    sig { params(index: RubyIndexer::Index).void }
+    #: (RubyIndexer::Index index) -> void
     def initialize(index)
       @index = index
     end
 
-    sig { params(node_context: NodeContext).returns(T.nilable(Type)) }
+    #: (NodeContext node_context) -> Type?
     def infer_receiver_type(node_context)
       node = node_context.node
 
@@ -31,7 +29,7 @@ module RubyLsp
 
     private
 
-    sig { params(node: Prism::CallNode, node_context: NodeContext).returns(T.nilable(Type)) }
+    #: (Prism::CallNode node, NodeContext node_context) -> Type?
     def infer_receiver_for_call_node(node, node_context)
       receiver = node.receiver
 
@@ -114,7 +112,7 @@ module RubyLsp
       end
     end
 
-    sig { params(raw_receiver: String, nesting: T::Array[String]).returns(T.nilable(GuessedType)) }
+    #: (String raw_receiver, Array[String] nesting) -> GuessedType?
     def guess_type(raw_receiver, nesting)
       guessed_name = raw_receiver
         .delete_prefix("@")
@@ -130,7 +128,7 @@ module RubyLsp
       GuessedType.new(name)
     end
 
-    sig { params(node_context: NodeContext).returns(Type) }
+    #: (NodeContext node_context) -> Type
     def self_receiver_handling(node_context)
       nesting = node_context.nesting
       # If we're at the top level, then the invocation is happening on `<main>`, which is a special singleton that
@@ -147,7 +145,7 @@ module RubyLsp
       Type.new("#{parts.join("::")}::<Class:#{parts.last}>")
     end
 
-    sig { params(node_context: NodeContext).returns(T.nilable(Type)) }
+    #: (NodeContext node_context) -> Type?
     def infer_receiver_for_class_variables(node_context)
       nesting_parts = node_context.nesting.dup
 
@@ -168,20 +166,21 @@ module RubyLsp
 
     # A known type
     class Type
-      extend T::Sig
-
-      sig { returns(String) }
+      #: String
       attr_reader :name
 
-      sig { params(name: String).void }
+      #: (String name) -> void
       def initialize(name)
         @name = name
       end
 
       # Returns the attached version of this type by removing the `<Class:...>` part from its name
-      sig { returns(Type) }
+      #: -> Type
       def attached
-        Type.new(T.must(@name.split("::")[..-2]).join("::"))
+        Type.new(
+          @name.split("::")[..-2] #: as !nil
+          .join("::"),
+        )
       end
     end
 

data/lib/ruby_lsp/utils.rb

@@ -9,22 +9,16 @@ module RubyLsp
   # rubocop:enable RubyLsp/UseLanguageServerAliases
 
   # Used to indicate that a request shouldn't return a response
-  BUNDLE_PATH = T.let(
-    begin
-      Bundler.bundle_path.to_s
-    rescue Bundler::GemfileNotFound
-      nil
-    end,
-    T.nilable(String),
-  )
-  GEMFILE_NAME = T.let(
-    begin
-      Bundler.with_original_env { Bundler.default_gemfile.basename.to_s }
-    rescue Bundler::GemfileNotFound
-      "Gemfile"
-    end,
-    String,
-  )
+  BUNDLE_PATH = begin
+    Bundler.bundle_path.to_s
+  rescue Bundler::GemfileNotFound
+    nil
+  end #: String?
+  GEMFILE_NAME = begin
+    Bundler.with_original_env { Bundler.default_gemfile.basename.to_s }
+  rescue Bundler::GemfileNotFound
+    "Gemfile"
+  end #: String
   GUESSED_TYPES_URL = "https://shopify.github.io/ruby-lsp/#guessed-types"
 
   # Request delegation for embedded languages is not yet standardized into the language server specification. Here we
@@ -44,15 +38,15 @@ module RubyLsp
     extend T::Sig
     extend T::Helpers
 
-    sig { returns(String) }
+    #: String
     attr_reader :method
 
-    sig { returns(Object) }
+    #: Object
     attr_reader :params
 
     abstract!
 
-    sig { params(method: String, params: Object).void }
+    #: (method: String, params: Object) -> void
     def initialize(method:, params:)
       @method = method
       @params = params
@@ -64,9 +58,7 @@ module RubyLsp
 
   class Notification < Message
     class << self
-      extend T::Sig
-
-      sig { params(message: String, type: Integer).returns(Notification) }
+      #: (String message, ?type: Integer) -> Notification
       def window_show_message(message, type: Constant::MessageType::INFO)
         new(
           method: "window/showMessage",
@@ -74,7 +66,7 @@ module RubyLsp
         )
       end
 
-      sig { params(message: String, type: Integer).returns(Notification) }
+      #: (String message, ?type: Integer) -> Notification
       def window_log_message(message, type: Constant::MessageType::LOG)
         new(
           method: "window/logMessage",
@@ -82,7 +74,7 @@ module RubyLsp
         )
       end
 
-      sig { params(data: T::Hash[Symbol, T.untyped]).returns(Notification) }
+      #: (Hash[Symbol, untyped] data) -> Notification
       def telemetry(data)
         new(
           method: "telemetry/event",
@@ -90,14 +82,7 @@ module RubyLsp
         )
       end
 
-      sig do
-        params(
-          id: String,
-          title: String,
-          percentage: T.nilable(Integer),
-          message: T.nilable(String),
-        ).returns(Notification)
-      end
+      #: (String id, String title, ?percentage: Integer?, ?message: String?) -> Notification
       def progress_begin(id, title, percentage: nil, message: nil)
         new(
           method: "$/progress",
@@ -113,13 +98,7 @@ module RubyLsp
         )
       end
 
-      sig do
-        params(
-          id: String,
-          percentage: T.nilable(Integer),
-          message: T.nilable(String),
-        ).returns(Notification)
-      end
+      #: (String id, ?percentage: Integer?, ?message: String?) -> Notification
       def progress_report(id, percentage: nil, message: nil)
         new(
           method: "$/progress",
@@ -134,7 +113,7 @@ module RubyLsp
         )
       end
 
-      sig { params(id: String).returns(Notification) }
+      #: (String id) -> Notification
       def progress_end(id)
         Notification.new(
           method: "$/progress",
@@ -145,13 +124,7 @@ module RubyLsp
         )
       end
 
-      sig do
-        params(
-          uri: String,
-          diagnostics: T::Array[Interface::Diagnostic],
-          version: T.nilable(Integer),
-        ).returns(Notification)
-      end
+      #: (String uri, Array[Interface::Diagnostic] diagnostics, ?version: Integer?) -> Notification
       def publish_diagnostics(uri, diagnostics, version: nil)
         new(
           method: "textDocument/publishDiagnostics",
@@ -160,30 +133,23 @@ module RubyLsp
       end
     end
 
-    extend T::Sig
-
-    sig { override.returns(T::Hash[Symbol, T.untyped]) }
+    # @override
+    #: -> Hash[Symbol, untyped]
     def to_hash
       hash = { method: @method }
-      hash[:params] = T.unsafe(@params).to_hash if @params
+
+      if @params
+        hash[:params] = @params #: as untyped
+          .to_hash
+      end
+
       hash
     end
   end
 
   class Request < Message
-    extend T::Sig
-
     class << self
-      extend T::Sig
-
-      sig do
-        params(
-          id: Integer,
-          pattern: T.any(Interface::RelativePattern, String),
-          kind: Integer,
-          registration_id: T.nilable(String),
-        ).returns(Request)
-      end
+      #: (Integer id, (Interface::RelativePattern | String) pattern, ?kind: Integer, ?registration_id: String?) -> Request
       def register_watched_files(
         id,
         pattern,
@@ -210,30 +176,34 @@ module RubyLsp
       end
     end
 
-    sig { params(id: T.any(Integer, String), method: String, params: Object).void }
+    #: (id: (Integer | String), method: String, params: Object) -> void
     def initialize(id:, method:, params:)
       @id = id
       super(method: method, params: params)
     end
 
-    sig { override.returns(T::Hash[Symbol, T.untyped]) }
+    # @override
+    #: -> Hash[Symbol, untyped]
     def to_hash
       hash = { id: @id, method: @method }
-      hash[:params] = T.unsafe(@params).to_hash if @params
+
+      if @params
+        hash[:params] = @params #: as untyped
+          .to_hash
+      end
+
       hash
     end
   end
 
   class Error
-    extend T::Sig
-
-    sig { returns(String) }
+    #: String
     attr_reader :message
 
-    sig { returns(Integer) }
+    #: Integer
     attr_reader :code
 
-    sig { params(id: Integer, code: Integer, message: String, data: T.nilable(T::Hash[Symbol, T.untyped])).void }
+    #: (id: Integer, code: Integer, message: String, ?data: Hash[Symbol, untyped]?) -> void
     def initialize(id:, code:, message:, data: nil)
       @id = id
       @code = code
@@ -241,7 +211,7 @@ module RubyLsp
       @data = data
     end
 
-    sig { returns(T::Hash[Symbol, T.untyped]) }
+    #: -> Hash[Symbol, untyped]
     def to_hash
       {
         id: @id,
@@ -256,21 +226,19 @@ module RubyLsp
 
   # The final result of running a request before its IO is finalized
   class Result
-    extend T::Sig
-
-    sig { returns(T.untyped) }
+    #: untyped
     attr_reader :response
 
-    sig { returns(Integer) }
+    #: Integer
     attr_reader :id
 
-    sig { params(id: Integer, response: T.untyped).void }
+    #: (id: Integer, response: untyped) -> void
     def initialize(id:, response:)
       @id = id
       @response = response
     end
 
-    sig { returns(T::Hash[Symbol, T.untyped]) }
+    #: -> Hash[Symbol, untyped]
     def to_hash
       { id: @id, result: @response }
     end
@@ -278,19 +246,60 @@ module RubyLsp
 
   # A request configuration, to turn on/off features
   class RequestConfig
-    extend T::Sig
-
-    sig { returns(T::Hash[Symbol, T::Boolean]) }
+    #: Hash[Symbol, bool]
     attr_accessor :configuration
 
-    sig { params(configuration: T::Hash[Symbol, T::Boolean]).void }
+    #: (Hash[Symbol, bool] configuration) -> void
     def initialize(configuration)
       @configuration = configuration
     end
 
-    sig { params(feature: Symbol).returns(T.nilable(T::Boolean)) }
+    #: (Symbol feature) -> bool?
     def enabled?(feature)
       @configuration[:enableAll] || @configuration[feature]
     end
   end
+
+  class SorbetLevel
+    class << self
+      #: -> SorbetLevel
+      def ignore
+        new("ignore")
+      end
+    end
+
+    #: (String?) -> void
+    def initialize(sigil)
+      @level = case sigil
+      when "ignore"
+        :ignore
+      when "false"
+        :false
+      when "true"
+        :true
+      when "strict", "strong"
+        :strict
+      else
+        :none
+      end #: Symbol
+    end
+
+    #: -> bool
+    def ignore? = @level == :ignore
+
+    #: -> bool
+    def false? = @level == :false
+
+    #: -> bool
+    def true? = @level == :true
+
+    #: -> bool
+    def strict? = @level == :strict
+
+    #: -> bool
+    def none? = @level == :none
+
+    #: -> bool
+    def true_or_higher? = @level == :true || @level == :strict
+  end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.23.11
+  version: 0.23.17
 platform: ruby
 authors:
 - Shopify
 bindir: exe
 cert_chain: []
-date: 2025-02-14 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -140,6 +140,8 @@ files:
 - lib/ruby_lsp/listeners/inlay_hints.rb
 - lib/ruby_lsp/listeners/semantic_highlighting.rb
 - lib/ruby_lsp/listeners/signature_help.rb
+- lib/ruby_lsp/listeners/spec_style.rb
+- lib/ruby_lsp/listeners/test_discovery.rb
 - lib/ruby_lsp/listeners/test_style.rb
 - lib/ruby_lsp/load_sorbet.rb
 - lib/ruby_lsp/node_context.rb
@@ -157,6 +159,7 @@ files:
 - lib/ruby_lsp/requests/document_symbol.rb
 - lib/ruby_lsp/requests/folding_ranges.rb
 - lib/ruby_lsp/requests/formatting.rb
+- lib/ruby_lsp/requests/go_to_relevant_file.rb
 - lib/ruby_lsp/requests/hover.rb
 - lib/ruby_lsp/requests/inlay_hints.rb
 - lib/ruby_lsp/requests/on_type_formatting.rb
@@ -199,6 +202,9 @@ files:
 - lib/ruby_lsp/static_docs.rb
 - lib/ruby_lsp/store.rb
 - lib/ruby_lsp/test_helper.rb
+- lib/ruby_lsp/test_reporters/lsp_reporter.rb
+- lib/ruby_lsp/test_reporters/minitest_reporter.rb
+- lib/ruby_lsp/test_reporters/test_unit_reporter.rb
 - lib/ruby_lsp/type_inferrer.rb
 - lib/ruby_lsp/utils.rb
 - static_docs/yield.md
@@ -222,7 +228,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.3
+rubygems_version: 3.6.8
 specification_version: 4
 summary: An opinionated language server for Ruby
 test_files: []