ruby-lsp 0.23.10 → 0.23.13

data/lib/ruby_lsp/setup_bundler.rb

@@ -25,50 +25,47 @@ module RubyLsp
     class BundleNotLocked < StandardError; end
     class BundleInstallFailure < StandardError; end
 
-    FOUR_HOURS = T.let(4 * 60 * 60, Integer)
+    FOUR_HOURS = 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))
-      @launcher = T.let(options[:launcher], T.nilable(T::Boolean))
+      @branch = options[:branch] #: String?
+      @launcher = options[:launcher] #: bool?
       patch_thor_to_print_progress_to_stderr! if @launcher
 
       # Regular bundle paths
-      @gemfile = T.let(
-        begin
-          Bundler.default_gemfile
-        rescue Bundler::GemfileNotFound
-          nil
-        end,
-        T.nilable(Pathname),
-      )
-      @lockfile = T.let(@gemfile ? Bundler.default_lockfile : nil, T.nilable(Pathname))
+      @gemfile = begin
+        Bundler.default_gemfile
+      rescue Bundler::GemfileNotFound
+        nil
+      end #: Pathname?
+      @lockfile = @gemfile ? Bundler.default_lockfile : nil #: Pathname?
 
-      @gemfile_hash = T.let(@gemfile ? Digest::SHA256.hexdigest(@gemfile.read) : nil, T.nilable(String))
-      @lockfile_hash = T.let(@lockfile&.exist? ? Digest::SHA256.hexdigest(@lockfile.read) : nil, T.nilable(String))
+      @gemfile_hash = @gemfile ? Digest::SHA256.hexdigest(@gemfile.read) : nil #: String?
+      @lockfile_hash = @lockfile&.exist? ? Digest::SHA256.hexdigest(@lockfile.read) : nil #: String?
 
-      @gemfile_name = T.let(@gemfile&.basename&.to_s || "Gemfile", String)
+      @gemfile_name = @gemfile&.basename&.to_s || "Gemfile" #: String
 
       # Custom bundle paths
-      @custom_dir = T.let(Pathname.new(".ruby-lsp").expand_path(@project_path), Pathname)
-      @custom_gemfile = T.let(@custom_dir + @gemfile_name, Pathname)
-      @custom_lockfile = T.let(@custom_dir + (@lockfile&.basename || "Gemfile.lock"), Pathname)
-      @lockfile_hash_path = T.let(@custom_dir + "main_lockfile_hash", Pathname)
-      @last_updated_path = T.let(@custom_dir + "last_updated", Pathname)
-      @error_path = T.let(@custom_dir + "install_error", Pathname)
-      @already_composed_path = T.let(@custom_dir + "bundle_is_composed", Pathname)
+      @custom_dir = Pathname.new(".ruby-lsp").expand_path(@project_path) #: Pathname
+      @custom_gemfile = @custom_dir + @gemfile_name #: Pathname
+      @custom_lockfile = @custom_dir + (@lockfile&.basename || "Gemfile.lock") #: Pathname
+      @lockfile_hash_path = @custom_dir + "main_lockfile_hash" #: Pathname
+      @last_updated_path = @custom_dir + "last_updated" #: Pathname
+      @error_path = @custom_dir + "install_error" #: Pathname
+      @already_composed_path = @custom_dir + "bundle_is_composed" #: Pathname
 
       dependencies, bundler_version = load_dependencies
-      @dependencies = T.let(dependencies, T::Hash[String, T.untyped])
-      @bundler_version = T.let(bundler_version, T.nilable(Gem::Version))
-      @rails_app = T.let(rails_app?, T::Boolean)
-      @retry = T.let(false, T::Boolean)
+      @dependencies = dependencies #: Hash[String, untyped]
+      @bundler_version = bundler_version #: Gem::Version?
+      @rails_app = rails_app? #: bool
+      @retry = false #: bool
     end
 
     # 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,26 +125,23 @@ module RubyLsp
 
     private
 
-    sig { returns(T::Hash[String, T.untyped]) }
+    #: -> Hash[String, untyped]
     def composed_bundle_dependencies
-      @composed_bundle_dependencies ||= T.let(
-        begin
-          original_bundle_gemfile = ENV["BUNDLE_GEMFILE"]
-
-          if @custom_lockfile.exist?
-            ENV["BUNDLE_GEMFILE"] = @custom_gemfile.to_s
-            Bundler::LockfileParser.new(@custom_lockfile.read).dependencies
-          else
-            {}
-          end
-        ensure
-          ENV["BUNDLE_GEMFILE"] = original_bundle_gemfile
-        end,
-        T.nilable(T::Hash[String, T.untyped]),
-      )
+      @composed_bundle_dependencies ||= begin
+        original_bundle_gemfile = ENV["BUNDLE_GEMFILE"]
+
+        if @custom_lockfile.exist?
+          ENV["BUNDLE_GEMFILE"] = @custom_gemfile.to_s
+          Bundler::LockfileParser.new(@custom_lockfile.read).dependencies
+        else
+          {}
+        end
+      ensure
+        ENV["BUNDLE_GEMFILE"] = original_bundle_gemfile
+      end #: Hash[String, untyped]?
     end
 
-    sig { void }
+    #: -> void
     def write_custom_gemfile
       parts = [
         "# This custom gemfile is automatically generated by the Ruby LSP.",
@@ -158,7 +152,8 @@ module RubyLsp
       # If there's a top level Gemfile, we want to evaluate from the composed bundle. We get the source from the top
       # level Gemfile, so if there isn't one we need to add a default source
       if @gemfile&.exist? && @lockfile&.exist?
-        parts << "eval_gemfile(File.expand_path(\"../#{@gemfile_name}\", __dir__))"
+        gemfile_path = @gemfile.relative_path_from(@custom_dir.realpath)
+        parts << "eval_gemfile(File.expand_path(\"#{gemfile_path}\", __dir__))"
       else
         parts.unshift('source "https://rubygems.org"')
       end
@@ -187,7 +182,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?
 
@@ -207,7 +202,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
@@ -258,7 +253,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)
 
@@ -268,7 +263,7 @@ module RubyLsp
       T.unsafe(ENV).merge!(env)
 
       unless should_update && !force_install
-        Bundler::CLI::Install.new({}).run
+        Bundler::CLI::Install.new({ "no-cache" => true }).run
         correct_relative_remote_paths if @custom_lockfile.exist?
         return env
       end
@@ -287,7 +282,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
@@ -344,7 +339,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")
 
@@ -356,18 +351,25 @@ 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|
-        key = Bundler::Settings.key_for(e)
+      settings
+        .all
+        .reject { |setting| ignored_settings.include?(setting) }
+        .to_h do |e|
+        key = settings.key_for(e)
         value = Array(settings[e]).join(":").tr(" ", ":")
 
         [key, value]
       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)
@@ -376,7 +378,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
@@ -399,7 +401,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|
@@ -421,7 +423,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?
@@ -430,7 +432,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/static_docs.rb

@@ -3,13 +3,10 @@
 
 module RubyLsp
   # The path to the `static_docs` directory, where we keep long-form static documentation
-  STATIC_DOCS_PATH = T.let(File.join(File.dirname(File.dirname(T.must(__dir__))), "static_docs"), String)
+  STATIC_DOCS_PATH = File.join(File.dirname(File.dirname(T.must(__dir__))), "static_docs") #: String
 
   # A map of keyword => short documentation to be displayed on hover or completion
-  KEYWORD_DOCS = T.let(
-    {
-      "yield" => "Invokes the passed block with the given arguments",
-    }.freeze,
-    T::Hash[String, String],
-  )
+  KEYWORD_DOCS = {
+    "yield" => "Invokes the passed block with the given arguments",
+  }.freeze #: Hash[String, String]
 end

data/lib/ruby_lsp/store.rb

@@ -3,34 +3,29 @@
 
 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]])
-      @features_configuration = T.let(
-        {
-          inlayHint: RequestConfig.new({
-            enableAll: false,
-            implicitRescue: false,
-            implicitHashValue: false,
-          }),
-        },
-        T::Hash[Symbol, RequestConfig],
-      )
-      @client_name = T.let("Unknown", String)
+      @state = {} #: Hash[String, Document[untyped]]
+      @features_configuration = {
+        inlayHint: RequestConfig.new({
+          enableAll: false,
+          implicitRescue: false,
+          implicitHashValue: false,
+        }),
+      } #: Hash[Symbol, RequestConfig]
+      @client_name = "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 +51,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 +63,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,207 @@
+# 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