ruby-lsp 0.23.11 → 0.25.0

data/lib/ruby_lsp/test_reporters/lsp_reporter.rb

@@ -0,0 +1,236 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "English"
+require "json"
+require "socket"
+require "singleton"
+require "tmpdir"
+require_relative "../../ruby_indexer/lib/ruby_indexer/uri"
+
+module RubyLsp
+  class LspReporter
+    include Singleton
+
+    # https://code.visualstudio.com/api/references/vscode-api#Position
+    #: type position = { line: Integer, character: Integer }
+
+    # https://code.visualstudio.com/api/references/vscode-api#Range
+    #: type range = { start: position, end: position }
+
+    # https://code.visualstudio.com/api/references/vscode-api#BranchCoverage
+    #: type branch_coverage = { executed: Integer, label: String, location: range }
+
+    # https://code.visualstudio.com/api/references/vscode-api#StatementCoverage
+    #: type statement_coverage = { executed: Integer, location: position, branches: Array[branch_coverage] }
+
+    #: bool
+    attr_reader :invoked_shutdown
+
+    #: -> void
+    def initialize
+      dir_path = File.join(Dir.tmpdir, "ruby-lsp")
+      FileUtils.mkdir_p(dir_path)
+
+      port_db_path = File.join(dir_path, "test_reporter_port_db.json")
+      port = ENV["RUBY_LSP_REPORTER_PORT"]
+
+      @io = begin
+        # The environment variable is only used for tests. The extension always writes to the temporary file
+        if port
+          TCPSocket.new("localhost", port)
+        elsif File.exist?(port_db_path)
+          db = JSON.load_file(port_db_path)
+          TCPSocket.new("localhost", db[Dir.pwd])
+        else
+          # For tests that don't spawn the TCP server
+          require "stringio"
+          StringIO.new
+        end
+      rescue
+        require "stringio"
+        StringIO.new
+      end #: IO | StringIO
+
+      @invoked_shutdown = false #: bool
+    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
+      @invoked_shutdown = true
+
+      send_message("finish")
+      @io.close
+    end
+
+    #: (id: String, uri: URI::Generic, ?line: Integer?) -> void
+    def start_test(id:, uri:, line: nil)
+      send_message("start", id: id, uri: uri.to_s, line: line)
+    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
+
+    #: (Method | UnboundMethod) -> [URI::Generic, Integer?]?
+    def uri_and_line_for(method_object)
+      file_path, line = method_object.source_location
+      return unless file_path
+      return if file_path.start_with?("(eval at ")
+
+      uri = URI::Generic.from_path(path: File.expand_path(file_path))
+      zero_based_line = line ? line - 1 : nil
+      [uri, zero_based_line]
+    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, statement_coverage]
+    def gather_coverage_results
+      # Ignore coverage results inside dependencies
+      bundle_path = Bundler.bundle_path.to_s
+
+      result = Coverage.result.reject do |file_path, _coverage_info|
+        file_path.start_with?(bundle_path) || !file_path.start_with?(Dir.pwd)
+      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
+
+    #: -> void
+    def at_coverage_exit
+      coverage_results = gather_coverage_results
+      File.write(File.join(".ruby-lsp", "coverage_result.json"), coverage_results.to_json)
+      internal_shutdown
+    end
+
+    #: -> void
+    def at_exit
+      internal_shutdown unless invoked_shutdown
+    end
+
+    class << self
+      #: -> bool
+      def start_coverage?
+        ENV["RUBY_LSP_TEST_RUNNER"] == "coverage"
+      end
+
+      #: -> bool
+      def executed_under_test_runner?
+        !!(ENV["RUBY_LSP_TEST_RUNNER"] && ENV["RUBY_LSP_ENV"] != "test")
+      end
+    end
+
+    private
+
+    #: (String?, **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 RubyLsp::LspReporter.start_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)
+end
+
+if RubyLsp::LspReporter.executed_under_test_runner?
+  at_exit do
+    # Regular finish events are registered per test reporter. However, if the test crashes during loading the files
+    # (e.g.: a bad require), we need to ensure that the execution is finalized so that the extension is not left hanging
+    RubyLsp::LspReporter.instance.at_exit if $ERROR_INFO
+  end
+end

data/lib/ruby_lsp/test_reporters/minitest_reporter.rb

@@ -0,0 +1,145 @@
+# typed: strict
+# frozen_string_literal: true
+
+begin
+  require "minitest"
+rescue LoadError
+  return
+end
+
+require_relative "lsp_reporter"
+
+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
+
+  # This patch is here to prevent other gems from overriding or adding more Minitest reporters. Otherwise, they may
+  # break the integration between the server and extension
+  module PreventReporterOverridePatch
+    @lsp_reporters = [] #: Array[Minitest::AbstractReporter]
+
+    class << self
+      #: Array[Minitest::AbstractReporter]
+      attr_accessor :lsp_reporters
+    end
+
+    # Patch the writer to prevent replacing the entire array
+    #: (untyped) -> void
+    def reporters=(reporters)
+      # Do nothing. We don't want other gems to override our reporter
+    end
+
+    # Patch the reader to prevent appending more reporters. This method always returns a temporary copy of the real
+    # reporters so that if any gem mutates it, it continues to return the original reporters
+    #: -> Array[untyped]
+    def reporters
+      PreventReporterOverridePatch.lsp_reporters.dup
+    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
+        PreventReporterOverridePatch.lsp_reporters = reporters
+        Minitest.reporter.class.prepend(PreventReporterOverridePatch)
+      end
+    end
+
+    #: (untyped, String) -> void
+    def prerecord(test_class_or_wrapper, method_name)
+      # In frameworks like Rails, they can control the Minitest execution by wrapping the test class
+      # But they conform to responding to `name`, so we can use that as a guarantee
+      # We are interested in the test class, not the wrapper
+      name = test_class_or_wrapper.name
+
+      klass = begin
+        Object.const_get(name) # rubocop:disable Sorbet/ConstantsFromStrings
+      rescue NameError
+        # Handle Minitest specs that create classes with invalid constant names like "MySpec::when something is true"
+        # If we can't resolve the constant, it means we were given the actual test class object, not the wrapper
+        test_class_or_wrapper
+      end
+
+      uri, line = LspReporter.instance.uri_and_line_for(klass.instance_method(method_name))
+      return unless uri
+
+      id = "#{name}##{handle_spec_test_id(method_name, line)}"
+      LspReporter.instance.start_test(id: id, uri: uri, line: line)
+    end
+
+    #: (Minitest::Result result) -> void
+    def record(result)
+      file_path, line = result.source_location
+      return unless file_path
+
+      zero_based_line = line ? line - 1 : nil
+      name = handle_spec_test_id(result.name, zero_based_line)
+      id = "#{result.klass}##{name}"
+
+      uri = URI::Generic.from_path(path: File.expand_path(file_path))
+
+      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
+
+    #: (String, Integer?) -> String
+    def handle_spec_test_id(method_name, line)
+      method_name.gsub(/(?<=test_)\d{4}(?=_)/, format("%04d", line.to_s))
+    end
+  end
+end
+
+Minitest.extensions << RubyLsp::MinitestReporter
+
+if RubyLsp::LspReporter.start_coverage?
+  Minitest.after_run do
+    RubyLsp::LspReporter.instance.at_coverage_exit
+  end
+elsif RubyLsp::LspReporter.executed_under_test_runner?
+  Minitest.after_run do
+    RubyLsp::LspReporter.instance.at_exit
+  end
+end

data/lib/ruby_lsp/test_reporters/test_unit_reporter.rb

@@ -0,0 +1,92 @@
+# 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"
+
+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
+
+      uri, line = LspReporter.instance.uri_and_line_for(test.method(test.method_name))
+      return unless uri
+
+      @current_uri = uri
+      @current_test_id = "#{test.class.name}##{test.method_name}"
+      LspReporter.instance.start_test(id: @current_test_id, uri: @current_uri, line: line)
+    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)
+      super
+      LspReporter.instance.shutdown
+    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
+
+if RubyLsp::LspReporter.start_coverage?
+  Test::Unit.at_exit do
+    RubyLsp::LspReporter.instance.at_coverage_exit
+  end
+elsif RubyLsp::LspReporter.executed_under_test_runner?
+  Test::Unit.at_exit do
+    RubyLsp::LspReporter.instance.at_exit
+  end
+end

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