ruby-lsp 0.23.11 → 0.23.16

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.",
@@ -188,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?
 
@@ -208,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
@@ -259,17 +253,18 @@ 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)
 
       # The ENV can only be merged after checking if an update is required because we depend on the original value of
       # ENV["BUNDLE_GEMFILE"], which gets overridden after the merge
       should_update = should_bundle_update?
-      T.unsafe(ENV).merge!(env)
+      ENV #: as untyped
+        .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
@@ -288,7 +283,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 +340,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 +352,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 +370,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 +379,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,16 +402,19 @@ 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|
-        path = T.must(Regexp.last_match)[1]
+        last_match = Regexp.last_match #: as !nil
+        path = last_match[1]
 
         # We should only apply the correction if the remote is a relative path. It might also be a URI, like
         # `https://rubygems.org` or an absolute path, in which case we shouldn't do anything
         if path && !URI(path).scheme
-          "remote: #{File.expand_path(path, T.must(@gemfile).dirname)}"
+          bundle_dir = @gemfile #: as !nil
+            .dirname
+          "remote: #{File.expand_path(path, bundle_dir)}"
         else
           match
         end
@@ -422,7 +427,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 +436,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,17 @@
 
 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(
+        __dir__, #: as !nil
+      ),
+    ),
+    "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?
@@ -51,19 +46,12 @@ module RubyLsp
       end
 
       set(uri: uri, source: File.binread(path), version: 0, language_id: language_id)
-      T.must(@state[uri.to_s])
+      @state[uri.to_s] #: as !nil
     rescue Errno::ENOENT
       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,40 @@ 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)
+      @state[uri.to_s] #: as !nil
+        .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)
@@ -58,7 +48,7 @@ module RubyLsp
       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_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