ruby-lsp 0.23.11 → 0.26.6

data/lib/ruby_lsp/global_state.rb

@@ -2,94 +2,115 @@
 # frozen_string_literal: true
 
 module RubyLsp
-  class GlobalState
-    extend T::Sig
+  # Holds the detected value and the reason for detection
+  class DetectionResult
+    #: String
+    attr_reader :value
+
+    #: String
+    attr_reader :reason
+
+    #: (String value, String reason) -> void
+    def initialize(value, reason)
+      @value = value
+      @reason = reason
+    end
+  end
 
-    sig { returns(String) }
+  class GlobalState
+    #: String
     attr_reader :test_library
 
-    sig { returns(String) }
+    #: String
     attr_accessor :formatter
 
-    sig { returns(T::Boolean) }
+    #: bool
     attr_reader :has_type_checker
 
-    sig { returns(RubyIndexer::Index) }
+    #: RubyIndexer::Index
     attr_reader :index
 
-    sig { returns(Encoding) }
+    #: Encoding
     attr_reader :encoding
 
-    sig { returns(T::Boolean) }
+    #: bool
     attr_reader :top_level_bundle
 
-    sig { returns(TypeInferrer) }
+    #: TypeInferrer
     attr_reader :type_inferrer
 
-    sig { returns(ClientCapabilities) }
+    #: ClientCapabilities
     attr_reader :client_capabilities
 
-    sig { returns(URI::Generic) }
+    #: URI::Generic
     attr_reader :workspace_uri
 
-    sig { returns(T.nilable(String)) }
+    #: String?
     attr_reader :telemetry_machine_id
 
-    sig { void }
+    #: -> void
     def initialize
-      @workspace_uri = T.let(URI::Generic.from_path(path: Dir.pwd), URI::Generic)
-      @encoding = T.let(Encoding::UTF_8, Encoding)
-
-      @formatter = T.let("auto", String)
-      @linters = T.let([], T::Array[String])
-      @test_library = T.let("minitest", String)
-      @has_type_checker = T.let(true, T::Boolean)
-      @index = T.let(RubyIndexer::Index.new, RubyIndexer::Index)
-      @supported_formatters = T.let({}, T::Hash[String, Requests::Support::Formatter])
-      @type_inferrer = T.let(TypeInferrer.new(@index), TypeInferrer)
-      @addon_settings = T.let({}, T::Hash[String, T.untyped])
-      @top_level_bundle = T.let(
-        begin
-          Bundler.with_original_env { Bundler.default_gemfile }
-          true
-        rescue Bundler::GemfileNotFound, Bundler::GitError
-          false
-        end,
-        T::Boolean,
-      )
-      @client_capabilities = T.let(ClientCapabilities.new, ClientCapabilities)
-      @enabled_feature_flags = T.let({}, T::Hash[Symbol, T::Boolean])
-      @mutex = T.let(Mutex.new, Mutex)
-      @telemetry_machine_id = T.let(nil, T.nilable(String))
+      @workspace_uri = URI::Generic.from_path(path: Dir.pwd) #: URI::Generic
+      @encoding = Encoding::UTF_8 #: Encoding
+
+      @formatter = "auto" #: String
+      @linters = [] #: Array[String]
+      @test_library = "minitest" #: String
+      @has_type_checker = true #: bool
+      @index = RubyIndexer::Index.new #: RubyIndexer::Index
+      @supported_formatters = {} #: Hash[String, Requests::Support::Formatter]
+      @type_inferrer = TypeInferrer.new(@index) #: TypeInferrer
+      @addon_settings = {} #: Hash[String, untyped]
+      @top_level_bundle = begin
+        Bundler.with_original_env { Bundler.default_gemfile }
+        true
+      rescue Bundler::GemfileNotFound, Bundler::GitError
+        false
+      end #: bool
+      @client_capabilities = ClientCapabilities.new #: ClientCapabilities
+      @enabled_feature_flags = {} #: Hash[Symbol, bool]
+      @mutex = Mutex.new #: Mutex
+      @telemetry_machine_id = nil #: String?
+      @feature_configuration = {
+        inlayHint: RequestConfig.new({
+          enableAll: false,
+          implicitRescue: false,
+          implicitHashValue: false,
+        }),
+        codeLens: RequestConfig.new({
+          enableAll: false,
+          enableTestCodeLens: true,
+        }),
+      } #: Hash[Symbol, RequestConfig]
     end
 
-    sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) }
+    #: [T] { -> T } -> T
     def synchronize(&block)
       @mutex.synchronize(&block)
     end
 
-    sig { params(addon_name: String).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
+    #: (String addon_name) -> Hash[Symbol, untyped]?
     def settings_for_addon(addon_name)
       @addon_settings[addon_name]
     end
 
-    sig { params(identifier: String, instance: Requests::Support::Formatter).void }
+    #: (String identifier, Requests::Support::Formatter instance) -> void
     def register_formatter(identifier, instance)
       @supported_formatters[identifier] = instance
     end
 
-    sig { returns(T.nilable(Requests::Support::Formatter)) }
+    #: -> Requests::Support::Formatter?
     def active_formatter
       @supported_formatters[@formatter]
     end
 
-    sig { returns(T::Array[Requests::Support::Formatter]) }
+    #: -> Array[Requests::Support::Formatter]
     def active_linters
       @linters.filter_map { |name| @supported_formatters[name] }
     end
 
     # Applies the options provided by the editor and returns an array of notifications to send back to the client
-    sig { params(options: T::Hash[Symbol, T.untyped]).returns(T::Array[Notification]) }
+    #: (Hash[Symbol, untyped] options) -> Array[Notification]
     def apply_options(options)
       notifications = []
       direct_dependencies = gather_direct_dependencies
@@ -116,8 +137,11 @@ module RubyLsp
       end
 
       if @formatter == "auto"
-        @formatter = detect_formatter(direct_dependencies, all_dependencies)
-        notifications << Notification.window_log_message("Auto detected formatter: #{@formatter}")
+        formatter_result = detect_formatter(direct_dependencies, all_dependencies)
+        @formatter = formatter_result.value
+        notifications << Notification.window_log_message(
+          "Auto detected formatter: #{@formatter} (#{formatter_result.reason})",
+        )
       end
 
       specified_linters = options.dig(:initializationOptions, :linters)
@@ -138,21 +162,28 @@ module RubyLsp
         specified_linters << "rubocop_internal"
       end
 
-      @linters = specified_linters || detect_linters(direct_dependencies, all_dependencies)
-
-      notifications << if specified_linters
-        Notification.window_log_message("Using linters specified by user: #{@linters.join(", ")}")
+      if specified_linters
+        @linters = specified_linters
+        notifications << Notification.window_log_message("Using linters specified by user: #{@linters.join(", ")}")
       else
-        Notification.window_log_message("Auto detected linters: #{@linters.join(", ")}")
+        linter_results = detect_linters(direct_dependencies, all_dependencies)
+        @linters = linter_results.map(&:value)
+        linter_messages = linter_results.map { |r| "#{r.value} (#{r.reason})" }
+        notifications << Notification.window_log_message("Auto detected linters: #{linter_messages.join(", ")}")
       end
 
-      @test_library = detect_test_library(direct_dependencies)
-      notifications << Notification.window_log_message("Detected test library: #{@test_library}")
+      test_library_result = detect_test_library(direct_dependencies)
+      @test_library = test_library_result.value
+      notifications << Notification.window_log_message(
+        "Detected test library: #{@test_library} (#{test_library_result.reason})",
+      )
 
-      @has_type_checker = detect_typechecker(all_dependencies)
-      if @has_type_checker
+      typechecker_result = detect_typechecker(all_dependencies)
+      @has_type_checker = !typechecker_result.nil?
+      if typechecker_result
         notifications << Notification.window_log_message(
-          "Ruby LSP detected this is a Sorbet project and will defer to the Sorbet LSP for some functionality",
+          "Ruby LSP detected this is a Sorbet project (#{typechecker_result.reason}) and will defer to the " \
+            "Sorbet LSP for some functionality",
         )
       end
 
@@ -180,20 +211,30 @@ module RubyLsp
       @enabled_feature_flags = enabled_flags if enabled_flags
 
       @telemetry_machine_id = options.dig(:initializationOptions, :telemetryMachineId)
+
+      options.dig(:initializationOptions, :featuresConfiguration)&.each do |feature_name, config|
+        @feature_configuration[feature_name]&.merge!(config)
+      end
+
       notifications
     end
 
-    sig { params(flag: Symbol).returns(T.nilable(T::Boolean)) }
+    #: (Symbol) -> RequestConfig?
+    def feature_configuration(feature_name)
+      @feature_configuration[feature_name]
+    end
+
+    #: (Symbol flag) -> bool?
     def enabled_feature?(flag)
       @enabled_feature_flags[:all] || @enabled_feature_flags[flag]
     end
 
-    sig { returns(String) }
+    #: -> String
     def workspace_path
-      T.must(@workspace_uri.to_standardized_path)
+      @workspace_uri.to_standardized_path #: as !nil
     end
 
-    sig { returns(String) }
+    #: -> String
     def encoding_name
       case @encoding
       when Encoding::UTF_8
@@ -205,80 +246,87 @@ module RubyLsp
       end
     end
 
-    sig { returns(T::Boolean) }
+    #: -> bool
     def supports_watching_files
       @client_capabilities.supports_watching_files
     end
 
     private
 
-    sig { params(direct_dependencies: T::Array[String], all_dependencies: T::Array[String]).returns(String) }
+    #: (Array[String] direct_dependencies, Array[String] all_dependencies) -> DetectionResult
     def detect_formatter(direct_dependencies, all_dependencies)
       # NOTE: Intentionally no $ at end, since we want to match rubocop-shopify, etc.
-      return "rubocop_internal" if direct_dependencies.any?(/^rubocop/)
+      if direct_dependencies.any?(/^rubocop/)
+        return DetectionResult.new("rubocop_internal", "direct dependency matching /^rubocop/")
+      end
 
-      syntax_tree_is_direct_dependency = direct_dependencies.include?("syntax_tree")
-      return "syntax_tree" if syntax_tree_is_direct_dependency
+      if direct_dependencies.include?("syntax_tree")
+        return DetectionResult.new("syntax_tree", "direct dependency")
+      end
 
-      rubocop_is_transitive_dependency = all_dependencies.include?("rubocop")
-      return "rubocop_internal" if dot_rubocop_yml_present && rubocop_is_transitive_dependency
+      if all_dependencies.include?("rubocop") && dot_rubocop_yml_present
+        return DetectionResult.new("rubocop_internal", "transitive dependency with .rubocop.yml present")
+      end
 
-      "none"
+      DetectionResult.new("none", "no formatter detected")
     end
 
     # Try to detect if there are linters in the project's dependencies. For auto-detection, we always only consider a
     # single linter. To have multiple linters running, the user must configure them manually
-    sig { params(dependencies: T::Array[String], all_dependencies: T::Array[String]).returns(T::Array[String]) }
+    #: (Array[String] dependencies, Array[String] all_dependencies) -> Array[DetectionResult]
     def detect_linters(dependencies, all_dependencies)
-      linters = []
+      linters = [] #: Array[DetectionResult]
 
-      if dependencies.any?(/^rubocop/) || (all_dependencies.include?("rubocop") && dot_rubocop_yml_present)
-        linters << "rubocop_internal"
+      if dependencies.any?(/^rubocop/)
+        linters << DetectionResult.new("rubocop_internal", "direct dependency matching /^rubocop/")
+      elsif all_dependencies.include?("rubocop") && dot_rubocop_yml_present
+        linters << DetectionResult.new("rubocop_internal", "transitive dependency with .rubocop.yml present")
       end
 
       linters
     end
 
-    sig { params(dependencies: T::Array[String]).returns(String) }
+    #: (Array[String] dependencies) -> DetectionResult
     def detect_test_library(dependencies)
       if dependencies.any?(/^rspec/)
-        "rspec"
+        DetectionResult.new("rspec", "direct dependency matching /^rspec/")
       # A Rails app may have a dependency on minitest, but we would instead want to use the Rails test runner provided
       # by ruby-lsp-rails. A Rails app doesn't need to depend on the rails gem itself, individual components like
       # activestorage may be added to the gemfile so that other components aren't downloaded. Check for the presence
       #  of bin/rails to support these cases.
       elsif bin_rails_present
-        "rails"
+        DetectionResult.new("rails", "bin/rails present")
       # NOTE: Intentionally ends with $ to avoid mis-matching minitest-reporters, etc. in a Rails app.
       elsif dependencies.any?(/^minitest$/)
-        "minitest"
+        DetectionResult.new("minitest", "direct dependency matching /^minitest$/")
       elsif dependencies.any?(/^test-unit/)
-        "test-unit"
+        DetectionResult.new("test-unit", "direct dependency matching /^test-unit/")
       else
-        "unknown"
+        DetectionResult.new("unknown", "no test library detected")
       end
     end
 
-    sig { params(dependencies: T::Array[String]).returns(T::Boolean) }
+    #: (Array[String] dependencies) -> DetectionResult?
     def detect_typechecker(dependencies)
-      return false if ENV["RUBY_LSP_BYPASS_TYPECHECKER"]
+      return if ENV["RUBY_LSP_BYPASS_TYPECHECKER"]
+      return if dependencies.none?(/^sorbet-static/)
 
-      dependencies.any?(/^sorbet-static/)
+      DetectionResult.new("sorbet", "sorbet-static in dependencies")
     rescue Bundler::GemfileNotFound
-      false
+      nil
     end
 
-    sig { returns(T::Boolean) }
+    #: -> bool
     def bin_rails_present
       File.exist?(File.join(workspace_path, "bin/rails"))
     end
 
-    sig { returns(T::Boolean) }
+    #: -> bool
     def dot_rubocop_yml_present
       File.exist?(File.join(workspace_path, ".rubocop.yml"))
     end
 
-    sig { returns(T::Array[String]) }
+    #: -> Array[String]
     def gather_direct_dependencies
       Bundler.with_original_env { Bundler.default_gemfile }
 
@@ -288,14 +336,14 @@ module RubyLsp
       []
     end
 
-    sig { returns(T::Array[String]) }
+    #: -> Array[String]
     def gemspec_dependencies
       (Bundler.locked_gems&.sources || [])
         .grep(Bundler::Source::Gemspec)
         .flat_map { _1.gemspec&.dependencies&.map(&:name) }
     end
 
-    sig { returns(T::Array[String]) }
+    #: -> Array[String]
     def gather_direct_and_indirect_dependencies
       Bundler.with_original_env { Bundler.default_gemfile }
       Bundler.locked_gems&.specs&.map(&:name) || []

data/lib/ruby_lsp/internal.rb

@@ -6,15 +6,18 @@
 yarp_require_paths = Gem.loaded_specs["yarp"]&.full_require_paths
 $LOAD_PATH.delete_if { |path| yarp_require_paths.include?(path) } if yarp_require_paths
 
-require "sorbet-runtime"
-
 # Set Bundler's UI level to silent as soon as possible to prevent any prints to STDOUT
 require "bundler"
 Bundler.ui.level = :silent
 
 require "json"
 require "uri"
-require "cgi"
+require "cgi/escape"
+if Gem::Version.new(RUBY_VERSION) < Gem::Version.new("3.5")
+  # Just requiring `cgi/escape` leaves CGI.unescape broken on older rubies
+  # Some background on why this is necessary: https://bugs.ruby-lang.org/issues/21258
+  require "cgi/util"
+end
 require "set"
 require "strscan"
 require "prism"
@@ -25,6 +28,7 @@ require "fileutils"
 require "open3"
 require "securerandom"
 require "shellwords"
+require "set"
 
 require "ruby-lsp"
 require "ruby_lsp/base_server"
@@ -79,6 +83,7 @@ require "ruby_lsp/requests/document_link"
 require "ruby_lsp/requests/document_symbol"
 require "ruby_lsp/requests/folding_ranges"
 require "ruby_lsp/requests/formatting"
+require "ruby_lsp/requests/go_to_relevant_file"
 require "ruby_lsp/requests/hover"
 require "ruby_lsp/requests/inlay_hints"
 require "ruby_lsp/requests/on_type_formatting"