ruby-lsp 0.23.11 → 0.23.12

data/lib/ruby_lsp/setup_bundler.rb

@@ -27,7 +27,7 @@ module RubyLsp
 
     FOUR_HOURS = T.let(4 * 60 * 60, Integer)
 
-    sig { params(project_path: String, options: T.untyped).void }
+    #: (String project_path, **untyped options) -> void
     def initialize(project_path, **options)
       @project_path = project_path
       @branch = T.let(options[:branch], T.nilable(String))
@@ -68,7 +68,7 @@ module RubyLsp
 
     # Sets up the composed bundle and returns the `BUNDLE_GEMFILE`, `BUNDLE_PATH` and `BUNDLE_APP_CONFIG` that should be
     # used for running the server
-    sig { returns(T::Hash[String, String]) }
+    #: -> Hash[String, String]
     def setup!
       raise BundleNotLocked if !@launcher && @gemfile&.exist? && !@lockfile&.exist?
 
@@ -128,7 +128,7 @@ module RubyLsp
 
     private
 
-    sig { returns(T::Hash[String, T.untyped]) }
+    #: -> Hash[String, untyped]
     def composed_bundle_dependencies
       @composed_bundle_dependencies ||= T.let(
         begin
@@ -147,7 +147,7 @@ module RubyLsp
       )
     end
 
-    sig { void }
+    #: -> void
     def write_custom_gemfile
       parts = [
         "# This custom gemfile is automatically generated by the Ruby LSP.",
@@ -188,7 +188,7 @@ module RubyLsp
       @custom_gemfile.write(content) unless @custom_gemfile.exist? && @custom_gemfile.read == content
     end
 
-    sig { returns([T::Hash[String, T.untyped], T.nilable(Gem::Version)]) }
+    #: -> [Hash[String, untyped], Gem::Version?]
     def load_dependencies
       return [{}, nil] unless @lockfile&.exist?
 
@@ -208,7 +208,7 @@ module RubyLsp
       [dependencies, lockfile_parser.bundler_version]
     end
 
-    sig { params(bundle_gemfile: T.nilable(Pathname)).returns(T::Hash[String, String]) }
+    #: (?Pathname? bundle_gemfile) -> Hash[String, String]
     def run_bundle_install(bundle_gemfile = @gemfile)
       env = bundler_settings_as_env
       env["BUNDLE_GEMFILE"] = bundle_gemfile.to_s
@@ -259,7 +259,7 @@ module RubyLsp
       env
     end
 
-    sig { params(env: T::Hash[String, String], force_install: T::Boolean).returns(T::Hash[String, String]) }
+    #: (Hash[String, String] env, ?force_install: bool) -> Hash[String, String]
     def run_bundle_install_directly(env, force_install: false)
       RubyVM::YJIT.enable if defined?(RubyVM::YJIT.enable)
 
@@ -288,7 +288,7 @@ module RubyLsp
       @retry ? env : run_bundle_install_directly(env, force_install: true)
     end
 
-    sig { params(env: T::Hash[String, String]).returns(T::Hash[String, String]) }
+    #: (Hash[String, String] env) -> Hash[String, String]
     def run_bundle_install_through_command(env)
       # If `ruby-lsp` and `debug` (and potentially `ruby-lsp-rails`) are already in the Gemfile, then we shouldn't try
       # to upgrade them or else we'll produce undesired source control changes. If the composed bundle was just created
@@ -345,7 +345,7 @@ module RubyLsp
     end
 
     # Gather all Bundler settings (global and local) and return them as a hash that can be used as the environment
-    sig { returns(T::Hash[String, String]) }
+    #: -> Hash[String, String]
     def bundler_settings_as_env
       local_config_path = File.join(@project_path, ".bundle")
 
@@ -357,10 +357,17 @@ module RubyLsp
         Bundler::Settings.new
       end
 
+      # List of Bundler settings that don't make sense for the composed bundle and are better controlled manually by the
+      # user
+      ignored_settings = ["bin", "cache_all", "cache_all_platforms"]
+
       # Map all settings to their environment variable names with `key_for` and their values. For example, the if the
       # setting name `e` is `path` with a value of `vendor/bundle`, then it will return `"BUNDLE_PATH" =>
       # "vendor/bundle"`
-      settings.all.to_h do |e|
+      settings
+        .all
+        .reject { |setting| ignored_settings.include?(setting) }
+        .to_h do |e|
         key = settings.key_for(e)
         value = Array(settings[e]).join(":").tr(" ", ":")
 
@@ -368,7 +375,7 @@ module RubyLsp
       end
     end
 
-    sig { void }
+    #: -> void
     def install_bundler_if_needed
       # Try to find the bundler version specified in the lockfile in installed gems. If not found, install it
       requirement = Gem::Requirement.new(@bundler_version.to_s)
@@ -377,7 +384,7 @@ module RubyLsp
       Gem.install("bundler", @bundler_version.to_s)
     end
 
-    sig { returns(T::Boolean) }
+    #: -> bool
     def should_bundle_update?
       # If `ruby-lsp`, `ruby-lsp-rails` and `debug` are in the Gemfile, then we shouldn't try to upgrade them or else it
       # will produce version control changes
@@ -400,7 +407,7 @@ module RubyLsp
 
     # When a lockfile has remote references based on relative file paths, we need to ensure that they are pointing to
     # the correct place since after copying the relative path is no longer valid
-    sig { void }
+    #: -> void
     def correct_relative_remote_paths
       content = @custom_lockfile.read
       content.gsub!(/remote: (.*)/) do |match|
@@ -422,7 +429,7 @@ module RubyLsp
     end
 
     # Detects if the project is a Rails app by looking if the superclass of the main class is `Rails::Application`
-    sig { returns(T::Boolean) }
+    #: -> bool
     def rails_app?
       config = Pathname.new("config/application.rb").expand_path
       application_contents = config.read(external_encoding: Encoding::UTF_8) if config.exist?
@@ -431,7 +438,7 @@ module RubyLsp
       /class .* < (::)?Rails::Application/.match?(application_contents)
     end
 
-    sig { void }
+    #: -> void
     def patch_thor_to_print_progress_to_stderr!
       return unless defined?(Bundler::Thor::Shell::Basic)
 

data/lib/ruby_lsp/store.rb

@@ -3,17 +3,15 @@
 
 module RubyLsp
   class Store
-    extend T::Sig
-
     class NonExistingDocumentError < StandardError; end
 
-    sig { returns(T::Hash[Symbol, RequestConfig]) }
+    #: Hash[Symbol, RequestConfig]
     attr_accessor :features_configuration
 
-    sig { returns(String) }
+    #: String
     attr_accessor :client_name
 
-    sig { params(global_state: GlobalState).void }
+    #: (GlobalState global_state) -> void
     def initialize(global_state)
       @global_state = global_state
       @state = T.let({}, T::Hash[String, Document[T.untyped]])
@@ -30,7 +28,7 @@ module RubyLsp
       @client_name = T.let("Unknown", String)
     end
 
-    sig { params(uri: URI::Generic).returns(Document[T.untyped]) }
+    #: (URI::Generic uri) -> Document[untyped]
     def get(uri)
       document = @state[uri.to_s]
       return document unless document.nil?
@@ -56,14 +54,7 @@ module RubyLsp
       raise NonExistingDocumentError, uri.to_s
     end
 
-    sig do
-      params(
-        uri: URI::Generic,
-        source: String,
-        version: Integer,
-        language_id: Document::LanguageId,
-      ).returns(Document[T.untyped])
-    end
+    #: (uri: URI::Generic, source: String, version: Integer, language_id: Document::LanguageId) -> Document[untyped]
     def set(uri:, source:, version:, language_id:)
       @state[uri.to_s] = case language_id
       when Document::LanguageId::ERB
@@ -75,46 +66,39 @@ module RubyLsp
       end
     end
 
-    sig { params(uri: URI::Generic, edits: T::Array[T::Hash[Symbol, T.untyped]], version: Integer).void }
+    #: (uri: URI::Generic, edits: Array[Hash[Symbol, untyped]], version: Integer) -> void
     def push_edits(uri:, edits:, version:)
       T.must(@state[uri.to_s]).push_edits(edits, version: version)
     end
 
-    sig { void }
+    #: -> void
     def clear
       @state.clear
     end
 
-    sig { returns(T::Boolean) }
+    #: -> bool
     def empty?
       @state.empty?
     end
 
-    sig { params(uri: URI::Generic).void }
+    #: (URI::Generic uri) -> void
     def delete(uri)
       @state.delete(uri.to_s)
     end
 
-    sig { params(uri: URI::Generic).returns(T::Boolean) }
+    #: (URI::Generic uri) -> bool
     def key?(uri)
       @state.key?(uri.to_s)
     end
 
-    sig { params(block: T.proc.params(uri: String, document: Document[T.untyped]).void).void }
+    #: { (String uri, Document[untyped] document) -> void } -> void
     def each(&block)
       @state.each do |uri, document|
         block.call(uri, document)
       end
     end
 
-    sig do
-      type_parameters(:T)
-        .params(
-          uri: URI::Generic,
-          request_name: String,
-          block: T.proc.params(document: Document[T.untyped]).returns(T.type_parameter(:T)),
-        ).returns(T.type_parameter(:T))
-    end
+    #: [T] (URI::Generic uri, String request_name) { (Document[untyped] document) -> T } -> T
     def cache_fetch(uri, request_name, &block)
       get(uri).cache_fetch(request_name, &block)
     end

data/lib/ruby_lsp/test_helper.rb

@@ -7,21 +7,11 @@ module RubyLsp
   module TestHelper
     class TestError < StandardError; end
 
-    extend T::Sig
     extend T::Helpers
 
     requires_ancestor { Kernel }
 
-    sig do
-      type_parameters(:T)
-        .params(
-          source: T.nilable(String),
-          uri: URI::Generic,
-          stub_no_typechecker: T::Boolean,
-          load_addons: T::Boolean,
-          block: T.proc.params(server: RubyLsp::Server, uri: URI::Generic).returns(T.type_parameter(:T)),
-        ).returns(T.type_parameter(:T))
-    end
+    #: [T] (?String? source, ?URI::Generic uri, ?stub_no_typechecker: bool, ?load_addons: bool) { (RubyLsp::Server server, URI::Generic uri) -> T } -> T
     def with_server(source = nil, uri = Kernel.URI("file:///fake.rb"), stub_no_typechecker: false, load_addons: true,
       &block)
       server = RubyLsp::Server.new(test_mode: true)
@@ -52,13 +42,14 @@ module RubyLsp
       ensure
         if load_addons
           RubyLsp::Addon.addons.each(&:deactivate)
+          RubyLsp::Addon.addon_classes.clear
           RubyLsp::Addon.addons.clear
         end
         server.run_shutdown
       end
     end
 
-    sig { params(server: RubyLsp::Server).returns(RubyLsp::Result) }
+    #: (RubyLsp::Server server) -> RubyLsp::Result
     def pop_result(server)
       result = server.pop_response
       result = server.pop_response until result.is_a?(RubyLsp::Result) || result.is_a?(RubyLsp::Error)

data/lib/ruby_lsp/test_reporter.rb

@@ -0,0 +1,71 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "json"
+
+$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, message: String?, uri: URI::Generic) -> void
+      def record_skip(id:, message:, uri:)
+        params = {
+          id: id,
+          message: message,
+          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
+
+      private
+
+      #: (method_name: String?, params: Hash[String, untyped]) -> void
+      def send_message(method_name, params)
+        json_message = { method: method_name, params: params }.to_json
+        $stdout.write("Content-Length: #{json_message.bytesize}\r\n\r\n#{json_message}")
+      end
+    end
+  end
+end

data/lib/ruby_lsp/test_unit_test_runner.rb

@@ -0,0 +1,96 @@
+# typed: true
+# frozen_string_literal: true
+
+require "test/unit"
+require "test/unit/ui/testrunner"
+require "ruby_lsp/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,
+        message: pending.message,
+        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 }

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,18 +166,16 @@ 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("::"))
       end