ruby-lsp 0.23.14 → 0.23.16

data/lib/ruby_lsp/test_reporters/lsp_reporter.rb

@@ -0,0 +1,164 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "json"
+require "socket"
+require "singleton"
+
+module RubyLsp
+  class LspReporter
+    include Singleton
+
+    #: -> void
+    def initialize
+      port = ENV["RUBY_LSP_REPORTER_PORT"]
+      @io = if port
+        TCPSocket.new("localhost", port)
+      else
+        # For tests that don't spawn the TCP server
+        require "stringio"
+        StringIO.new
+      end #: IO | StringIO
+    end
+
+    #: -> void
+    def shutdown
+      # When running in coverage mode, we don't want to inform the extension that we finished immediately after running
+      # tests. We only do it after we finish processing coverage results, by invoking `internal_shutdown`
+      return if ENV["RUBY_LSP_TEST_RUNNER"] == "coverage"
+
+      internal_shutdown
+    end
+
+    # This method is intended to be used by the RubyLsp::LspReporter class itself only. If you're writing a custom test
+    # reporter, use `shutdown` instead
+    #: -> void
+    def internal_shutdown
+      send_message("finish")
+      @io.close
+    end
+
+    #: (id: String, uri: URI::Generic) -> void
+    def start_test(id:, uri:)
+      send_message("start", id: id, uri: uri.to_s)
+    end
+
+    #: (id: String, uri: URI::Generic) -> void
+    def record_pass(id:, uri:)
+      send_message("pass", id: id, uri: uri.to_s)
+    end
+
+    #: (id: String, message: String, uri: URI::Generic) -> void
+    def record_fail(id:, message:, uri:)
+      send_message("fail", id: id, message: message, uri: uri.to_s)
+    end
+
+    #: (id: String, uri: URI::Generic) -> void
+    def record_skip(id:, uri:)
+      send_message("skip", id: id, uri: uri.to_s)
+    end
+
+    #: (id: String, message: String?, uri: URI::Generic) -> void
+    def record_error(id:, message:, uri:)
+      send_message("error", id: id, message: message, uri: uri.to_s)
+    end
+
+    # Gather the results returned by Coverage.result and format like the VS Code test explorer expects
+    #
+    # Coverage result format:
+    #
+    # Lines are reported in order as an array where each number is the number of times it was executed. For example,
+    # the following says that line 0 was executed 1 time and line 1 executed 3 times: [1, 3].
+    # Nil values represent lines for which coverage is not available, like empty lines, comments or keywords like
+    # `else`
+    #
+    # Branches are a hash containing the name of the branch and the location where it is found in tuples with the
+    # following elements: [NAME, ID, START_LINE, START_COLUMN, END_LINE, END_COLUMN] as the keys and the value is the
+    # number of times it was executed
+    #
+    # Methods are a similar hash [ClassName, :method_name, START_LINE, START_COLUMN, END_LINE, END_COLUMN] => NUMBER
+    # OF EXECUTIONS
+    #
+    # Example:
+    # {
+    #   "file_path" => {
+    #     "lines" => [1, 2, 3, nil],
+    #     "branches" => {
+    #       ["&.", 0, 6, 21, 6, 65] => { [:then, 1, 6, 21, 6, 65] => 0, [:else, 5, 7, 0, 7, 87] => 1 }
+    #     },
+    #     "methods" => {
+    #       ["Foo", :bar, 6, 21, 6, 65] => 0
+    #     }
+    # }
+    #: -> Hash[String, StatementCoverage]
+    def gather_coverage_results
+      # Ignore coverage results inside dependencies
+      bundle_path = Bundler.bundle_path.to_s
+      default_gems_path = File.dirname(RbConfig::CONFIG["rubylibdir"])
+
+      result = Coverage.result.reject do |file_path, _coverage_info|
+        file_path.start_with?(bundle_path, default_gems_path, "eval")
+      end
+
+      result.to_h do |file_path, coverage_info|
+        # Format the branch coverage information as VS Code expects it and then group it based on the start line of
+        # the conditional that causes the branching. We need to match each line coverage data with the branches that
+        # spawn from that line
+        branch_by_line = coverage_info[:branches]
+          .flat_map do |branch, data|
+            branch_name, _branch_id, branch_start_line, _branch_start_col, _branch_end_line, _branch_end_col = branch
+
+            data.map do |then_or_else, execution_count|
+              name, _id, start_line, start_column, end_line, end_column = then_or_else
+
+              {
+                groupingLine: branch_start_line,
+                executed: execution_count,
+                location: {
+                  start: { line: start_line, character: start_column },
+                  end: { line: end_line, character: end_column },
+                },
+                label: "#{branch_name} #{name}",
+              }
+            end
+          end
+          .group_by { |branch| branch[:groupingLine] }
+
+        # Format the line coverage information, gathering any branch coverage data associated with that line
+        data = coverage_info[:lines].filter_map.with_index do |execution_count, line_index|
+          next if execution_count.nil?
+
+          {
+            executed: execution_count,
+            location: { line: line_index, character: 0 },
+            branches: branch_by_line[line_index] || [],
+          }
+        end
+
+        # The expected format is URI => { executed: number_of_times_executed, location: { ... }, branches: [ ... ] }
+        [URI::Generic.from_path(path: File.expand_path(file_path)).to_s, data]
+      end
+    end
+
+    private
+
+    #: (method_name: String?, params: untyped) -> void
+    def send_message(method_name, **params)
+      json_message = { method: method_name, params: params }.to_json
+      @io.write("Content-Length: #{json_message.bytesize}\r\n\r\n#{json_message}")
+    end
+  end
+end
+
+if ENV["RUBY_LSP_TEST_RUNNER"] == "coverage"
+  # Auto start coverage when running tests under that profile. This avoids the user from having to configure coverage
+  # manually for their project or adding extra dependencies
+  require "coverage"
+  Coverage.start(:all)
+
+  at_exit do
+    coverage_results = RubyLsp::LspReporter.instance.gather_coverage_results
+    File.write(File.join(".ruby-lsp", "coverage_result.json"), coverage_results.to_json)
+    RubyLsp::LspReporter.instance.internal_shutdown
+  end
+end

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

@@ -177,7 +177,10 @@ module RubyLsp
       # Returns the attached version of this type by removing the `<Class:...>` part from its name
       #: -> 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

@@ -137,7 +137,12 @@ module RubyLsp
     #: -> 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
@@ -181,7 +186,12 @@ module RubyLsp
     #: -> 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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.23.14
+  version: 0.23.16
 platform: ruby
 authors:
 - Shopify
 bindir: exe
 cert_chain: []
-date: 2025-04-09 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -194,7 +194,6 @@ files:
 - lib/ruby_lsp/response_builders/signature_help.rb
 - lib/ruby_lsp/response_builders/test_collection.rb
 - lib/ruby_lsp/ruby_document.rb
-- lib/ruby_lsp/ruby_lsp_reporter_plugin.rb
 - lib/ruby_lsp/scope.rb
 - lib/ruby_lsp/scripts/compose_bundle.rb
 - lib/ruby_lsp/scripts/compose_bundle_windows.rb
@@ -203,8 +202,9 @@ files:
 - lib/ruby_lsp/static_docs.rb
 - lib/ruby_lsp/store.rb
 - lib/ruby_lsp/test_helper.rb
-- lib/ruby_lsp/test_reporter.rb
-- lib/ruby_lsp/test_unit_test_runner.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
@@ -228,7 +228,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.6
+rubygems_version: 3.6.8
 specification_version: 4
 summary: An opinionated language server for Ruby
 test_files: []

data/lib/ruby_lsp/ruby_lsp_reporter_plugin.rb

@@ -1,109 +0,0 @@
-# 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