ruby-lsp 0.23.11 → 0.26.1

data/lib/ruby_lsp/global_state.rb

@@ -3,93 +3,99 @@
 
 module RubyLsp
   class GlobalState
-    extend T::Sig
-
-    sig { returns(String) }
+    #: 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
@@ -180,20 +186,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,14 +221,14 @@ 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) -> String
     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/)
@@ -228,7 +244,7 @@ module RubyLsp
 
     # 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[String]
     def detect_linters(dependencies, all_dependencies)
       linters = []
 
@@ -239,7 +255,7 @@ module RubyLsp
       linters
     end
 
-    sig { params(dependencies: T::Array[String]).returns(String) }
+    #: (Array[String] dependencies) -> String
     def detect_test_library(dependencies)
       if dependencies.any?(/^rspec/)
         "rspec"
@@ -259,7 +275,7 @@ module RubyLsp
       end
     end
 
-    sig { params(dependencies: T::Array[String]).returns(T::Boolean) }
+    #: (Array[String] dependencies) -> bool
     def detect_typechecker(dependencies)
       return false if ENV["RUBY_LSP_BYPASS_TYPECHECKER"]
 
@@ -268,17 +284,17 @@ module RubyLsp
       false
     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 +304,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"

data/lib/ruby_lsp/listeners/code_lens.rb

@@ -6,45 +6,32 @@ require "shellwords"
 module RubyLsp
   module Listeners
     class CodeLens
-      extend T::Sig
       include Requests::Support::Common
 
-      BASE_COMMAND = T.let(
-        begin
-          Bundler.with_original_env { Bundler.default_lockfile }
-          "bundle exec ruby"
-        rescue Bundler::GemfileNotFound
-          "ruby"
-        end,
-        String,
-      )
-      ACCESS_MODIFIERS = T.let([:public, :private, :protected], T::Array[Symbol])
-      SUPPORTED_TEST_LIBRARIES = T.let(["minitest", "test-unit"], T::Array[String])
-      DESCRIBE_KEYWORD = T.let(:describe, Symbol)
-      IT_KEYWORD = T.let(:it, Symbol)
-      DYNAMIC_REFERENCE_MARKER = T.let("<dynamic_reference>", String)
-
-      sig do
-        params(
-          response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens],
-          global_state: GlobalState,
-          uri: URI::Generic,
-          dispatcher: Prism::Dispatcher,
-        ).void
-      end
+      BASE_COMMAND = begin
+        Bundler.with_original_env { Bundler.default_lockfile }
+        "bundle exec ruby"
+      rescue Bundler::GemfileNotFound
+        "ruby"
+      end #: String
+      ACCESS_MODIFIERS = [:public, :private, :protected] #: Array[Symbol]
+      SUPPORTED_TEST_LIBRARIES = ["minitest", "test-unit"] #: Array[String]
+      DYNAMIC_REFERENCE_MARKER = "<dynamic_reference>" #: String
+
+      #: (ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens] response_builder, GlobalState global_state, URI::Generic uri, Prism::Dispatcher dispatcher) -> void
       def initialize(response_builder, global_state, uri, dispatcher)
         @response_builder = response_builder
         @global_state = global_state
-        @uri = T.let(uri, URI::Generic)
-        @path = T.let(uri.to_standardized_path, T.nilable(String))
+        @uri = uri #: URI::Generic
+        @path = uri.to_standardized_path #: String?
         # visibility_stack is a stack of [current_visibility, previous_visibility]
-        @visibility_stack = T.let([[:public, :public]], T::Array[T::Array[T.nilable(Symbol)]])
-        @group_stack = T.let([], T::Array[String])
-        @group_id = T.let(1, Integer)
-        @group_id_stack = T.let([], T::Array[Integer])
+        @visibility_stack = [[:public, :public]] #: Array[Array[Symbol?]]
+        @group_stack = [] #: Array[String]
+        @group_id = 1 #: Integer
+        @group_id_stack = [] #: Array[Integer]
         # We want to avoid adding code lenses for nested definitions
-        @def_depth = T.let(0, Integer)
-        @spec_id = T.let(0, Integer)
+        @def_depth = 0 #: Integer
+        @spec_id = 0 #: Integer
 
         dispatcher.register(
           self,
@@ -59,7 +46,7 @@ module RubyLsp
         )
       end
 
-      sig { params(node: Prism::ClassNode).void }
+      #: (Prism::ClassNode node) -> void
       def on_class_node_enter(node)
         @visibility_stack.push([:public, :public])
         class_name = node.constant_path.slice
@@ -79,7 +66,7 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::ClassNode).void }
+      #: (Prism::ClassNode node) -> void
       def on_class_node_leave(node)
         @visibility_stack.pop
         @group_stack.pop
@@ -91,7 +78,7 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::DefNode).void }
+      #: (Prism::DefNode node) -> void
       def on_def_node_enter(node)
         @def_depth += 1
         return if @def_depth > 1
@@ -114,12 +101,12 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::DefNode).void }
+      #: (Prism::DefNode node) -> void
       def on_def_node_leave(node)
         @def_depth -= 1
       end
 
-      sig { params(node: Prism::ModuleNode).void }
+      #: (Prism::ModuleNode node) -> void
       def on_module_node_enter(node)
         if (path = namespace_constant_name(node))
           @group_stack.push(path)
@@ -128,12 +115,12 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::ModuleNode).void }
+      #: (Prism::ModuleNode node) -> void
       def on_module_node_leave(node)
         @group_stack.pop
       end
 
-      sig { params(node: Prism::CallNode).void }
+      #: (Prism::CallNode node) -> void
       def on_call_node_enter(node)
         name = node.name
         arguments = node.arguments
@@ -151,23 +138,21 @@ module RubyLsp
           return
         end
 
-        if [DESCRIBE_KEYWORD, IT_KEYWORD].include?(name)
-          case name
-          when DESCRIBE_KEYWORD
-            add_spec_code_lens(node, kind: :group)
-            @group_id_stack.push(@group_id)
-            @group_id += 1
-          when IT_KEYWORD
-            add_spec_code_lens(node, kind: :example)
-          end
+        case name
+        when :describe
+          add_spec_code_lens(node, kind: :group)
+          @group_id_stack.push(@group_id)
+          @group_id += 1
+        when :it, :specify # `specify` is an alias for `it`
+          add_spec_code_lens(node, kind: :example)
         end
       end
 
-      sig { params(node: Prism::CallNode).void }
+      #: (Prism::CallNode node) -> void
       def on_call_node_leave(node)
         _, prev_visibility = @visibility_stack.pop
         @visibility_stack.push([prev_visibility, prev_visibility])
-        if node.name == DESCRIBE_KEYWORD
+        if node.name == :describe
           @group_id_stack.pop
           @group_stack.pop
         end
@@ -175,7 +160,7 @@ module RubyLsp
 
       private
 
-      sig { params(node: Prism::Node, name: String, command: String, kind: Symbol, id: String).void }
+      #: (Prism::Node node, name: String, command: String, kind: Symbol, ?id: String) -> void
       def add_test_code_lens(node, name:, command:, kind:, id: name)
         # don't add code lenses if the test library is not supported or unknown
         return unless SUPPORTED_TEST_LIBRARIES.include?(@global_state.test_library) && @path
@@ -221,15 +206,9 @@ module RubyLsp
         )
       end
 
-      sig do
-        params(
-          group_stack: T::Array[String],
-          spec_name: T.nilable(String),
-          method_name: T.nilable(String),
-        ).returns(String)
-      end
+      #: (?group_stack: Array[String], ?spec_name: String?, ?method_name: String?) -> String
       def generate_test_command(group_stack: [], spec_name: nil, method_name: nil)
-        path = T.must(@path)
+        path = @path #: as !nil
         command = BASE_COMMAND
         command += " -Itest" if File.fnmatch?("**/test/**/*", path, File::FNM_PATHNAME)
         command += " -Ispec" if File.fnmatch?("**/spec/**/*", path, File::FNM_PATHNAME)
@@ -237,44 +216,58 @@ module RubyLsp
 
         case @global_state.test_library
         when "minitest"
-          last_dynamic_reference_index = group_stack.rindex(DYNAMIC_REFERENCE_MARKER)
-          command += if last_dynamic_reference_index
-            # In cases where the test path looks like `foo::Bar`
-            # the best we can do is match everything to the right of it.
-            # Tests are classes, dynamic references are only a thing for modules,
-            # so there must be something to the left of the available path.
-            group_stack = T.must(group_stack[last_dynamic_reference_index + 1..])
-            if method_name
-              " --name " + "/::#{Shellwords.escape(group_stack.join("::")) + "#" + Shellwords.escape(method_name)}$/"
-            else
-              # When clicking on a CodeLens for `Test`, `(#|::)` will match all tests
-              # that are registered on the class itself (matches after `#`) and all tests
-              # that are nested inside of that class in other modules/classes (matches after `::`)
-              " --name " + "\"/::#{Shellwords.escape(group_stack.join("::"))}(#|::)/\""
-            end
-          elsif method_name
-            # We know the entire path, do an exact match
-            " --name " + Shellwords.escape(group_stack.join("::")) + "#" + Shellwords.escape(method_name)
-          elsif spec_name
-            " --name " + "\"/^#{Shellwords.escape(group_stack.join("::"))}##{Shellwords.escape(spec_name)}$/\""
-          else
-            # Execute all tests of the selected class and tests in
-            # modules/classes nested inside of that class
-            " --name " + "\"/^#{Shellwords.escape(group_stack.join("::"))}(#|::)/\""
-          end
+          command += generate_minitest_command(group_stack, method_name, spec_name)
         when "test-unit"
-          group_name = T.must(group_stack.last)
-          command += " --testcase " + "/#{Shellwords.escape(group_name)}/"
+          command += generate_test_unit_command(group_stack, method_name)
+        end
+
+        command
+      end
+
+      #: (Array[String] group_stack, String? method_name, String? spec_name) -> String
+      def generate_minitest_command(group_stack, method_name, spec_name)
+        last_dynamic_reference_index = group_stack.rindex(DYNAMIC_REFERENCE_MARKER)
+
+        if last_dynamic_reference_index
+          # In cases where the test path looks like `foo::Bar`
+          # the best we can do is match everything to the right of it.
+          # Tests are classes, dynamic references are only a thing for modules,
+          # so there must be something to the left of the available path.
+          dynamic_stack = group_stack[last_dynamic_reference_index + 1..] #: as !nil
 
           if method_name
-            command += " --name " + Shellwords.escape(method_name)
+            " --name " + "/::#{Shellwords.escape(dynamic_stack.join("::")) + "#" + Shellwords.escape(method_name)}$/"
+          else
+            # When clicking on a CodeLens for `Test`, `(#|::)` will match all tests
+            # that are registered on the class itself (matches after `#`) and all tests
+            # that are nested inside of that class in other modules/classes (matches after `::`)
+            " --name " + "\"/::#{Shellwords.escape(dynamic_stack.join("::"))}(#|::)/\""
           end
+        elsif method_name
+          # We know the entire path, do an exact match
+          " --name " + Shellwords.escape(group_stack.join("::")) + "#" + Shellwords.escape(method_name)
+        elsif spec_name
+          " --name " + "\"/^#{Shellwords.escape(group_stack.join("::"))}##{Shellwords.escape(spec_name)}$/\""
+        else
+          # Execute all tests of the selected class and tests in
+          # modules/classes nested inside of that class
+          " --name " + "\"/^#{Shellwords.escape(group_stack.join("::"))}(#|::)/\""
+        end
+      end
+
+      #: (Array[String] group_stack, String? method_name) -> String
+      def generate_test_unit_command(group_stack, method_name)
+        group_name = group_stack.last #: as !nil
+        command = " --testcase " + "/#{Shellwords.escape(group_name)}/"
+
+        if method_name
+          command += " --name " + Shellwords.escape(method_name)
         end
 
         command
       end
 
-      sig { params(node: Prism::CallNode, kind: Symbol).void }
+      #: (Prism::CallNode node, kind: Symbol) -> void
       def add_spec_code_lens(node, kind:)
         arguments = node.arguments
         return unless arguments
@@ -312,7 +305,7 @@ module RubyLsp
         end
       end
 
-      sig { params(group_stack: T::Array[String], method_name: T.nilable(String)).returns(String) }
+      #: (group_stack: Array[String], ?method_name: String?) -> String
       def generate_fully_qualified_id(group_stack:, method_name: nil)
         if method_name
           # For tests, this will be the test class and method name: `Foo::BarTest#test_baz`.