ruby-lsp 0.23.14 → 0.23.15

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
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.23.14
+  version: 0.23.15
 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

data/lib/ruby_lsp/test_reporter.rb

@@ -1,207 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-require "json"
-require "delegate"
-
-$stdout.binmode
-$stdout.sync = true
-$stderr.binmode
-$stderr.sync = true
-
-module RubyLsp
-  module TestReporter
-    class << self
-      #: (id: String, uri: URI::Generic) -> void
-      def start_test(id:, uri:)
-        params = {
-          id: id,
-          uri: uri.to_s,
-        }
-        send_message("start", params)
-      end
-
-      #: (id: String, uri: URI::Generic) -> void
-      def record_pass(id:, uri:)
-        params = {
-          id: id,
-          uri: uri.to_s,
-        }
-        send_message("pass", params)
-      end
-
-      #: (id: String, message: String, uri: URI::Generic) -> void
-      def record_fail(id:, message:, uri:)
-        params = {
-          id: id,
-          message: message,
-          uri: uri.to_s,
-        }
-        send_message("fail", params)
-      end
-
-      #: (id: String, uri: URI::Generic) -> void
-      def record_skip(id:, uri:)
-        params = {
-          id: id,
-          uri: uri.to_s,
-        }
-        send_message("skip", params)
-      end
-
-      #: (id: String, message: String?, uri: URI::Generic) -> void
-      def record_error(id:, message:, uri:)
-        params = {
-          id: id,
-          message: message,
-          uri: uri.to_s,
-        }
-        send_message("error", params)
-      end
-
-      #: (message: String) -> void
-      def append_output(message:)
-        params = {
-          message: message,
-        }
-        send_message("append_output", params)
-      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) ||
-            file_path.start_with?(default_gems_path) ||
-            file_path.start_with?("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: Hash[String, untyped]) -> void
-      def send_message(method_name, params)
-        json_message = { method: method_name, params: params }.to_json
-        ORIGINAL_STDOUT.write("Content-Length: #{json_message.bytesize}\r\n\r\n#{json_message}")
-      end
-    end
-
-    ORIGINAL_STDOUT = $stdout #: IO
-
-    class IOWrapper < SimpleDelegator
-      #: (Object) -> void
-      def puts(*args)
-        args.each { |arg| log(convert_line_breaks(arg) + "\r\n") }
-      end
-
-      #: (Object) -> void
-      def print(*args)
-        args.each { |arg| log(convert_line_breaks(arg)) }
-      end
-
-      #: (Object) -> void
-      def write(*args)
-        args.each { |arg| log(convert_line_breaks(arg)) }
-      end
-
-      private
-
-      #: (Object) -> String
-      def convert_line_breaks(message)
-        message.to_s.gsub("\n", "\r\n")
-      end
-
-      #: (String) -> void
-      def log(message)
-        TestReporter.append_output(message: message)
-      end
-    end
-  end
-end
-
-if ENV["RUBY_LSP_TEST_RUNNER"]
-  # We wrap the default output stream so that we can capture anything written to stdout and emit it as part of the JSON
-  # event stream.
-  $> = RubyLsp::TestReporter::IOWrapper.new($stdout)
-
-  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::TestReporter.gather_coverage_results
-      File.write(File.join(".ruby-lsp", "coverage_result.json"), coverage_results.to_json)
-    end
-  end
-end

data/lib/ruby_lsp/test_unit_test_runner.rb

@@ -1,98 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-begin
-  require "test/unit"
-  require "test/unit/ui/testrunner"
-rescue LoadError
-  return
-end
-
-require_relative "test_reporter"
-require "ruby_indexer/lib/ruby_indexer/uri"
-
-module RubyLsp
-  class TestRunner < ::Test::Unit::UI::TestRunner
-    private
-
-    #: (::Test::Unit::TestCase test) -> void
-    def test_started(test)
-      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}"
-      TestReporter.start_test(
-        id: @current_test_id,
-        uri: @current_uri,
-      )
-    end
-
-    #: (::Test::Unit::TestCase test) -> void
-    def test_finished(test)
-      if test.passed?
-        TestReporter.record_pass(
-          id: @current_test_id,
-          uri: @current_uri,
-        )
-      end
-    end
-
-    #: (::Test::Unit::Failure | ::Test::Unit::Error | ::Test::Unit::Pending result) -> void
-    def result_fault(result)
-      case result
-      when ::Test::Unit::Failure
-        record_failure(result)
-      when ::Test::Unit::Error
-        record_error(result)
-      when ::Test::Unit::Pending
-        record_skip(result)
-      end
-    end
-
-    #: (::Test::Unit::Failure failure) -> void
-    def record_failure(failure)
-      TestReporter.record_fail(
-        id: @current_test_id,
-        message: failure.message,
-        uri: @current_uri,
-      )
-    end
-
-    #: (::Test::Unit::Error error) -> void
-    def record_error(error)
-      TestReporter.record_error(
-        id: @current_test_id,
-        message: error.message,
-        uri: @current_uri,
-      )
-    end
-
-    #: (::Test::Unit::Pending pending) -> void
-    def record_skip(pending)
-      TestReporter.record_skip(id: @current_test_id, uri: @current_uri)
-    end
-
-    #: (::Test::Unit::TestCase test) -> URI::Generic?
-    def uri_for_test(test)
-      location = test.method(test.method_name).source_location
-      return unless location # TODO: when might this be nil?
-
-      file, _line = location
-      return if file.start_with?("(eval at ") # test is dynamically defined (TODO: better way to check?)
-
-      absolute_path = File.expand_path(file, Dir.pwd)
-      URI::Generic.from_path(path: absolute_path)
-    end
-
-    #: -> void
-    def attach_to_mediator
-      @mediator.add_listener(Test::Unit::TestResult::FAULT, &method(:result_fault))
-      @mediator.add_listener(Test::Unit::TestCase::STARTED_OBJECT, &method(:test_started))
-      @mediator.add_listener(Test::Unit::TestCase::FINISHED_OBJECT, &method(:test_finished))
-    end
-  end
-end
-
-Test::Unit::AutoRunner.register_runner(:ruby_lsp) { |_auto_runner| RubyLsp::TestRunner }
-Test::Unit::AutoRunner.default_runner = :ruby_lsp