ruby-lsp 0.13.0 → 0.13.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d6bace664e1540c1333df9dabfb2e7bdd8bda0f910033b47b188e4a82ddacb15
-  data.tar.gz: be9e5da0492b26b5cb6e07074d01d7874104b70286c1578342b9639158fed147
+  metadata.gz: 78df9c8d35fc18cea6fc06a0f679b48b69e3daaaf504d762d2f5ae4df9d99ad0
+  data.tar.gz: 3c251eed7939e81c5aa115d303b2876d3769c509ef0487b0faa26d1a2de79c50
 SHA512:
-  metadata.gz: 7d8e61433686271a68dafe8db79765ed509a115ab6f06060d7669d279f48218fe2eada2c12e3b45f155d27a41774771681cdab92700d27f426e75ed89287ca03
-  data.tar.gz: 611c050b751050934d0fd93e9e52089fe63fc4d947be75a440dfa0465933814d2682268a10135d036c2cee83fa739156d2b11e42e679ecbed7de62acfee9d621
+  metadata.gz: af33b81309429318e7fe61dc4a2bd989328b8e9127097ab621eab162e61e1b2d93f1be1b192307d3b48f47659489343e093d92125e9c68895c40517803dba5ed
+  data.tar.gz: 6373eb77209eb865e29026fba603f4db8d3249949bcff7c0aee3f550569a7225c84b76d5872fd61a8798c0ef04da2d538b50b4d3045697ef40cc85336a2c715b

data/VERSION

@@ -1 +1 @@
-0.13.0
+0.13.1

data/lib/ruby_indexer/lib/ruby_indexer/entry.rb

@@ -106,6 +106,21 @@ module RubyIndexer
     class OptionalKeywordParameter < Parameter
     end
 
+    # A rest method parameter, e.g. `def foo(*a)`
+    class RestParameter < Parameter
+      DEFAULT_NAME = T.let(:"<anonymous splat>", Symbol)
+    end
+
+    # A keyword rest method parameter, e.g. `def foo(**a)`
+    class KeywordRestParameter < Parameter
+      DEFAULT_NAME = T.let(:"<anonymous keyword splat>", Symbol)
+    end
+
+    # A block method parameter, e.g. `def foo(&block)`
+    class BlockParameter < Parameter
+      DEFAULT_NAME = T.let(:"<anonymous block>", Symbol)
+    end
+
     class Member < Entry
       extend T::Sig
       extend T::Helpers
@@ -203,17 +218,50 @@ module RubyIndexer
           end
         end
 
+        rest = parameters_node.rest
+
+        if rest
+          rest_name = rest.name || RestParameter::DEFAULT_NAME
+          parameters << RestParameter.new(name: rest_name)
+        end
+
+        keyword_rest = parameters_node.keyword_rest
+
+        if keyword_rest.is_a?(Prism::KeywordRestParameterNode)
+          keyword_rest_name = parameter_name(keyword_rest) || KeywordRestParameter::DEFAULT_NAME
+          parameters << KeywordRestParameter.new(name: keyword_rest_name)
+        end
+
+        parameters_node.posts.each do |post|
+          name = parameter_name(post)
+          next unless name
+
+          parameters << RequiredParameter.new(name: name)
+        end
+
+        block = parameters_node.block
+        parameters << BlockParameter.new(name: block.name || BlockParameter::DEFAULT_NAME) if block
+
         parameters
       end
 
-      sig { params(node: Prism::Node).returns(T.nilable(Symbol)) }
+      sig { params(node: T.nilable(Prism::Node)).returns(T.nilable(Symbol)) }
       def parameter_name(node)
         case node
         when Prism::RequiredParameterNode, Prism::OptionalParameterNode,
-          Prism::RequiredKeywordParameterNode, Prism::OptionalKeywordParameterNode
+          Prism::RequiredKeywordParameterNode, Prism::OptionalKeywordParameterNode,
+          Prism::RestParameterNode, Prism::KeywordRestParameterNode
           node.name
         when Prism::MultiTargetNode
-          names = [*node.lefts, *node.rest, *node.rights].map { |parameter_node| parameter_name(parameter_node) }
+          names = node.lefts.map { |parameter_node| parameter_name(parameter_node) }
+
+          rest = node.rest
+          if rest.is_a?(Prism::SplatNode)
+            name = rest.expression&.slice
+            names << (rest.operator == "*" ? "*#{name}".to_sym : name&.to_sym)
+          end
+
+          names.concat(node.rights.map { |parameter_node| parameter_name(parameter_node) })
 
           names_with_commas = names.join(", ")
           :"(#{names_with_commas})"

data/lib/ruby_indexer/test/method_test.rb

@@ -106,6 +106,142 @@ module RubyIndexer
       assert_instance_of(Entry::OptionalKeywordParameter, b)
     end
 
+    def test_method_with_rest_and_keyword_rest_parameters
+      index(<<~RUBY)
+        class Foo
+          def bar(*a, **b)
+          end
+        end
+      RUBY
+
+      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+      entry = T.must(@index["bar"].first)
+      assert_equal(2, entry.parameters.length)
+      a, b = entry.parameters
+
+      assert_equal(:a, a.name)
+      assert_instance_of(Entry::RestParameter, a)
+
+      assert_equal(:b, b.name)
+      assert_instance_of(Entry::KeywordRestParameter, b)
+    end
+
+    def test_method_with_post_parameters
+      index(<<~RUBY)
+        class Foo
+          def bar(*a, b)
+          end
+
+          def baz(**a, b)
+          end
+
+          def qux(*a, (b, c))
+        end
+      RUBY
+
+      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+      entry = T.must(@index["bar"].first)
+      assert_equal(2, entry.parameters.length)
+      a, b = entry.parameters
+
+      assert_equal(:a, a.name)
+      assert_instance_of(Entry::RestParameter, a)
+
+      assert_equal(:b, b.name)
+      assert_instance_of(Entry::RequiredParameter, b)
+
+      entry = T.must(@index["baz"].first)
+      assert_equal(2, entry.parameters.length)
+      a, b = entry.parameters
+
+      assert_equal(:a, a.name)
+      assert_instance_of(Entry::KeywordRestParameter, a)
+
+      assert_equal(:b, b.name)
+      assert_instance_of(Entry::RequiredParameter, b)
+
+      entry = T.must(@index["qux"].first)
+      assert_equal(2, entry.parameters.length)
+      _a, second = entry.parameters
+
+      assert_equal(:"(b, c)", second.name)
+      assert_instance_of(Entry::RequiredParameter, second)
+    end
+
+    def test_method_with_destructured_rest_parameters
+      index(<<~RUBY)
+        class Foo
+          def bar((a, *b))
+          end
+        end
+      RUBY
+
+      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+      entry = T.must(@index["bar"].first)
+      assert_equal(1, entry.parameters.length)
+      param = entry.parameters.first
+
+      assert_equal(:"(a, *b)", param.name)
+      assert_instance_of(Entry::RequiredParameter, param)
+    end
+
+    def test_method_with_block_parameters
+      index(<<~RUBY)
+        class Foo
+          def bar(&block)
+          end
+
+          def baz(&)
+          end
+        end
+      RUBY
+
+      entry = T.must(@index["bar"].first)
+      param = entry.parameters.first
+      assert_equal(:block, param.name)
+      assert_instance_of(Entry::BlockParameter, param)
+
+      entry = T.must(@index["baz"].first)
+      assert_equal(1, entry.parameters.length)
+
+      param = entry.parameters.first
+      assert_equal(Entry::BlockParameter::DEFAULT_NAME, param.name)
+      assert_instance_of(Entry::BlockParameter, param)
+    end
+
+    def test_method_with_anonymous_rest_parameters
+      index(<<~RUBY)
+        class Foo
+          def bar(*, **)
+          end
+        end
+      RUBY
+
+      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+      entry = T.must(@index["bar"].first)
+      assert_equal(2, entry.parameters.length)
+      first, second = entry.parameters
+
+      assert_equal(Entry::RestParameter::DEFAULT_NAME, first.name)
+      assert_instance_of(Entry::RestParameter, first)
+
+      assert_equal(Entry::KeywordRestParameter::DEFAULT_NAME, second.name)
+      assert_instance_of(Entry::KeywordRestParameter, second)
+    end
+
+    def test_method_with_forbidden_keyword_splat_parameter
+      index(<<~RUBY)
+        class Foo
+          def bar(**nil)
+          end
+        end
+      RUBY
+
+      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+      entry = T.must(@index["bar"].first)
+      assert_empty(entry.parameters)
+    end
+
     def test_keeps_track_of_method_owner
       index(<<~RUBY)
         class Foo

data/lib/ruby_lsp/document.rb

@@ -24,6 +24,9 @@ module RubyLsp
     sig { returns(URI::Generic) }
     attr_reader :uri
 
+    sig { returns(String) }
+    attr_reader :encoding
+
     sig { params(source: String, version: Integer, uri: URI::Generic, encoding: String).void }
     def initialize(source:, version:, uri:, encoding: Constant::PositionEncodingKind::UTF8)
       @cache = T.let({}, T::Hash[String, T.untyped])

data/lib/ruby_lsp/executor.rb

@@ -98,7 +98,8 @@ module RubyLsp
         folding_range = Requests::FoldingRanges.new(document.parse_result.comments, dispatcher)
         document_symbol = Requests::DocumentSymbol.new(dispatcher)
         document_link = Requests::DocumentLink.new(uri, document.comments, dispatcher)
-        code_lens = Requests::CodeLens.new(uri, dispatcher)
+        lenses_configuration = T.must(@store.features_configuration.dig(:codeLens))
+        code_lens = Requests::CodeLens.new(uri, lenses_configuration, dispatcher)
 
         semantic_highlighting = Requests::SemanticHighlighting.new(dispatcher)
         dispatcher.dispatch(document.tree)
@@ -392,7 +393,8 @@ module RubyLsp
       end_line = range.dig(:end, :line)
 
       dispatcher = Prism::Dispatcher.new
-      listener = Requests::InlayHints.new(start_line..end_line, dispatcher)
+      hints_configurations = T.must(@store.features_configuration.dig(:inlayHint))
+      listener = Requests::InlayHints.new(start_line..end_line, hints_configurations, dispatcher)
       dispatcher.visit(document.tree)
       listener.response
     end
@@ -602,6 +604,11 @@ module RubyLsp
       configured_features = options.dig(:initializationOptions, :enabledFeatures)
       @store.experimental_features = options.dig(:initializationOptions, :experimentalFeaturesEnabled) || false
 
+      configured_hints = options.dig(:initializationOptions, :featuresConfiguration, :inlayHint)
+      configured_lenses = options.dig(:initializationOptions, :featuresConfiguration, :codeLens)
+      T.must(@store.features_configuration.dig(:inlayHint)).configuration.merge!(configured_hints) if configured_hints
+      T.must(@store.features_configuration.dig(:codeLens)).configuration.merge!(configured_lenses) if configured_lenses
+
       enabled_features = case configured_features
       when Array
         # If the configuration is using an array, then absent features are disabled and present ones are enabled. That's
@@ -663,7 +670,7 @@ module RubyLsp
       on_type_formatting_provider = if enabled_features["onTypeFormatting"]
         Interface::DocumentOnTypeFormattingOptions.new(
           first_trigger_character: "{",
-          more_trigger_character: ["\n", "|"],
+          more_trigger_character: ["\n", "|", "d"],
         )
       end
 

data/lib/ruby_lsp/requests/code_actions.rb

@@ -38,14 +38,8 @@ module RubyLsp
       def run
         diagnostics = @context[:diagnostics]
 
-        code_actions = diagnostics.filter_map do |diagnostic|
-          code_action = diagnostic.dig(:data, :code_action)
-          next if code_action.nil?
-
-          # We want to return only code actions that are within range or that do not have any edits, such as refactor
-          # code actions
-          range = code_action.dig(:edit, :documentChanges, 0, :edits, 0, :range)
-          code_action if diagnostic.dig(:data, :correctable) && cover?(range)
+        code_actions = diagnostics.flat_map do |diagnostic|
+          diagnostic.dig(:data, :code_actions) || []
         end
 
         # Only add refactor actions if there's a non empty selection in the editor
@@ -55,14 +49,6 @@ module RubyLsp
 
       private
 
-      sig { params(range: T.nilable(Document::RangeShape)).returns(T::Boolean) }
-      def cover?(range)
-        range.nil? ||
-          ((@range.dig(:start, :line))..(@range.dig(:end, :line))).cover?(
-            (range.dig(:start, :line))..(range.dig(:end, :line)),
-          )
-      end
-
       sig { params(range: Document::RangeShape, uri: URI::Generic).returns(Interface::CodeAction) }
       def refactor_code_action(range, uri)
         Interface::CodeAction.new(

data/lib/ruby_lsp/requests/code_lens.rb

@@ -11,6 +11,10 @@ module RubyLsp
     # [code lens](https://microsoft.github.io/language-server-protocol/specification#textDocument_codeLens)
     # request informs the editor of runnable commands such as tests
     #
+    # # Configuration
+    #
+    # To disable gem code lenses, set `rubyLsp.featuresConfiguration.codeLens.gemfileLinks` to `false`.
+    #
     # # Example
     #
     # ```ruby
@@ -47,8 +51,14 @@ module RubyLsp
       sig { override.returns(ResponseType) }
       attr_reader :_response
 
-      sig { params(uri: URI::Generic, dispatcher: Prism::Dispatcher).void }
-      def initialize(uri, dispatcher)
+      sig do
+        params(
+          uri: URI::Generic,
+          lenses_configuration: RequestConfig,
+          dispatcher: Prism::Dispatcher,
+        ).void
+      end
+      def initialize(uri, lenses_configuration, dispatcher)
         @uri = T.let(uri, URI::Generic)
         @_response = T.let([], ResponseType)
         @path = T.let(uri.to_standardized_path, T.nilable(String))
@@ -57,6 +67,7 @@ module RubyLsp
         @class_stack = T.let([], T::Array[String])
         @group_id = T.let(1, Integer)
         @group_id_stack = T.let([], T::Array[Integer])
+        @lenses_configuration = lenses_configuration
 
         super(dispatcher)
 
@@ -134,6 +145,8 @@ module RubyLsp
         end
 
         if @path&.include?(GEMFILE_NAME) && name == :gem && arguments
+          return unless @lenses_configuration.enabled?(:gemfileLinks)
+
           first_argument = arguments.arguments.first
           return unless first_argument.is_a?(Prism::StringNode)
 

data/lib/ruby_lsp/requests/inlay_hints.rb

@@ -9,6 +9,14 @@ module RubyLsp
     # are labels added directly in the code that explicitly show the user something that might
     # otherwise just be implied.
     #
+    # # Configuration
+    #
+    # To enable rescue hints, set `rubyLsp.featuresConfiguration.inlayHint.implicitRescue` to `true`.
+    #
+    # To enable hash value hints, set `rubyLsp.featuresConfiguration.inlayHint.implicitHashValue` to `true`.
+    #
+    # To enable all hints, set `rubyLsp.featuresConfiguration.inlayHint.enableAll` to `true`.
+    #
     # # Example
     #
     # ```ruby
@@ -39,18 +47,26 @@ module RubyLsp
       sig { override.returns(ResponseType) }
       attr_reader :_response
 
-      sig { params(range: T::Range[Integer], dispatcher: Prism::Dispatcher).void }
-      def initialize(range, dispatcher)
+      sig do
+        params(
+          range: T::Range[Integer],
+          hints_configuration: RequestConfig,
+          dispatcher: Prism::Dispatcher,
+        ).void
+      end
+      def initialize(range, hints_configuration, dispatcher)
         super(dispatcher)
 
         @_response = T.let([], ResponseType)
         @range = range
+        @hints_configuration = hints_configuration
 
         dispatcher.register(self, :on_rescue_node_enter, :on_implicit_node_enter)
       end
 
       sig { params(node: Prism::RescueNode).void }
       def on_rescue_node_enter(node)
+        return unless @hints_configuration.enabled?(:implicitRescue)
         return unless node.exceptions.empty?
 
         loc = node.location
@@ -66,6 +82,7 @@ module RubyLsp
 
       sig { params(node: Prism::ImplicitNode).void }
       def on_implicit_node_enter(node)
+        return unless @hints_configuration.enabled?(:implicitHashValue)
         return unless visible?(node, @range)
 
         node_value = node.value

data/lib/ruby_lsp/requests/on_type_formatting.rb

@@ -60,6 +60,8 @@ module RubyLsp
               handle_statement_end
             end
           end
+        when "d"
+          auto_indent_after_end_keyword
         end
 
         @edits
@@ -118,7 +120,7 @@ module RubyLsp
         current_line = @lines[@position[:line]]
         next_line = @lines[@position[:line] + 1]
 
-        if current_line.nil? || current_line.strip.empty?
+        if current_line.nil? || current_line.strip.empty? || current_line.include?(")") || current_line.include?("]")
           add_edit_with_text("\n")
           add_edit_with_text("#{indents}end")
           move_cursor_to(@position[:line], @indentation + 2)
@@ -185,6 +187,32 @@ module RubyLsp
 
         count
       end
+
+      sig { void }
+      def auto_indent_after_end_keyword
+        current_line = @lines[@position[:line]]
+        return unless current_line&.strip == "end"
+
+        target, _parent, _nesting = @document.locate_node({
+          line: @position[:line],
+          character: @position[:character] - 1,
+        })
+
+        statements = case target
+        when Prism::IfNode, Prism::UnlessNode, Prism::ForNode, Prism::WhileNode, Prism::UntilNode
+          target.statements
+        end
+        return unless statements
+
+        statements.body.each do |node|
+          loc = node.location
+          next unless loc.start_column == @indentation
+
+          add_edit_with_text("  ", { line: loc.start_line - 1, character: 0 })
+        end
+
+        move_cursor_to(@position[:line], @position[:character])
+      end
     end
   end
 end

data/lib/ruby_lsp/requests/support/rubocop_diagnostic.rb

@@ -19,30 +19,23 @@ module RubyLsp
           T::Hash[Symbol, Integer],
         )
 
-        sig { params(offense: RuboCop::Cop::Offense, uri: URI::Generic).void }
-        def initialize(offense, uri)
+        # TODO: avoid passing document once we have alternative ways to get at
+        # encoding and file source
+        sig { params(document: Document, offense: RuboCop::Cop::Offense, uri: URI::Generic).void }
+        def initialize(document, offense, uri)
+          @document = document
           @offense = offense
           @uri = uri
         end
 
-        sig { returns(Interface::CodeAction) }
-        def to_lsp_code_action
-          Interface::CodeAction.new(
-            title: "Autocorrect #{@offense.cop_name}",
-            kind: Constant::CodeActionKind::QUICK_FIX,
-            edit: Interface::WorkspaceEdit.new(
-              document_changes: [
-                Interface::TextDocumentEdit.new(
-                  text_document: Interface::OptionalVersionedTextDocumentIdentifier.new(
-                    uri: @uri.to_s,
-                    version: nil,
-                  ),
-                  edits: @offense.correctable? ? offense_replacements : [],
-                ),
-              ],
-            ),
-            is_preferred: true,
-          )
+        sig { returns(T::Array[Interface::CodeAction]) }
+        def to_lsp_code_actions
+          code_actions = []
+
+          code_actions << autocorrect_action if @offense.correctable?
+          code_actions << disable_line_action
+
+          code_actions
         end
 
         sig { returns(Interface::Diagnostic) }
@@ -65,7 +58,7 @@ module RubyLsp
             ),
             data: {
               correctable: @offense.correctable?,
-              code_action: to_lsp_code_action,
+              code_actions: to_lsp_code_actions,
             },
           )
         end
@@ -90,6 +83,26 @@ module RubyLsp
           Interface::CodeDescription.new(href: doc_url) if doc_url
         end
 
+        sig { returns(Interface::CodeAction) }
+        def autocorrect_action
+          Interface::CodeAction.new(
+            title: "Autocorrect #{@offense.cop_name}",
+            kind: Constant::CodeActionKind::QUICK_FIX,
+            edit: Interface::WorkspaceEdit.new(
+              document_changes: [
+                Interface::TextDocumentEdit.new(
+                  text_document: Interface::OptionalVersionedTextDocumentIdentifier.new(
+                    uri: @uri.to_s,
+                    version: nil,
+                  ),
+                  edits: @offense.correctable? ? offense_replacements : [],
+                ),
+              ],
+            ),
+            is_preferred: true,
+          )
+        end
+
         sig { returns(T::Array[Interface::TextEdit]) }
         def offense_replacements
           @offense.corrector.as_replacements.map do |range, replacement|
@@ -102,6 +115,64 @@ module RubyLsp
             )
           end
         end
+
+        sig { returns(Interface::CodeAction) }
+        def disable_line_action
+          Interface::CodeAction.new(
+            title: "Disable #{@offense.cop_name} for this line",
+            kind: Constant::CodeActionKind::QUICK_FIX,
+            edit: Interface::WorkspaceEdit.new(
+              document_changes: [
+                Interface::TextDocumentEdit.new(
+                  text_document: Interface::OptionalVersionedTextDocumentIdentifier.new(
+                    uri: @uri.to_s,
+                    version: nil,
+                  ),
+                  edits: line_disable_comment,
+                ),
+              ],
+            ),
+          )
+        end
+
+        sig { returns(T::Array[Interface::TextEdit]) }
+        def line_disable_comment
+          new_text = if @offense.source_line.include?(" # rubocop:disable ")
+            ",#{@offense.cop_name}"
+          else
+            " # rubocop:disable #{@offense.cop_name}"
+          end
+
+          eol = Interface::Position.new(
+            line: @offense.line - 1,
+            character: length_of_line(@offense.source_line),
+          )
+
+          # TODO: fails for multiline strings - may be preferable to use block
+          # comments to disable some offenses
+          inline_comment = Interface::TextEdit.new(
+            range: Interface::Range.new(start: eol, end: eol),
+            new_text: new_text,
+          )
+
+          [inline_comment]
+        end
+
+        sig { params(line: String).returns(Integer) }
+        def length_of_line(line)
+          if @document.encoding == Constant::PositionEncodingKind::UTF16
+            line_length = 0
+            line.codepoints.each do |codepoint|
+              line_length += 1
+              if codepoint > RubyLsp::Document::Scanner::SURROGATE_PAIR_START
+                line_length += 1
+              end
+            end
+            line_length
+          else
+            line.length
+          end
+        end
       end
     end
   end

data/lib/ruby_lsp/requests/support/rubocop_diagnostics_runner.rb

@@ -25,7 +25,7 @@ module RubyLsp
           @runner.run(filename, document.source)
 
           @runner.offenses.map do |offense|
-            Support::RuboCopDiagnostic.new(offense, uri)
+            Support::RuboCopDiagnostic.new(document, offense, uri)
           end
         end
       end

data/lib/ruby_lsp/store.rb

@@ -20,6 +20,9 @@ module RubyLsp
     sig { returns(URI::Generic) }
     attr_accessor :workspace_uri
 
+    sig { returns(T::Hash[Symbol, RequestConfig]) }
+    attr_accessor :features_configuration
+
     sig { void }
     def initialize
       @state = T.let({}, T::Hash[String, Document])
@@ -28,6 +31,20 @@ module RubyLsp
       @supports_progress = T.let(true, T::Boolean)
       @experimental_features = T.let(false, T::Boolean)
       @workspace_uri = T.let(URI::Generic.from_path(path: Dir.pwd), URI::Generic)
+      @features_configuration = T.let(
+        {
+          codeLens: RequestConfig.new({
+            enableAll: false,
+            gemfileLinks: true,
+          }),
+          inlayHint: RequestConfig.new({
+            enableAll: false,
+            implicitRescue: false,
+            implicitHashValue: false,
+          }),
+        },
+        T::Hash[Symbol, RequestConfig],
+      )
     end
 
     sig { params(uri: URI::Generic).returns(Document) }

data/lib/ruby_lsp/utils.rb

@@ -74,4 +74,22 @@ module RubyLsp
       @cancelled = true
     end
   end
+
+  # A request configuration, to turn on/off features
+  class RequestConfig
+    extend T::Sig
+
+    sig { returns(T::Hash[Symbol, T::Boolean]) }
+    attr_accessor :configuration
+
+    sig { params(configuration: T::Hash[Symbol, T::Boolean]).void }
+    def initialize(configuration)
+      @configuration = configuration
+    end
+
+    sig { params(feature: Symbol).returns(T.nilable(T::Boolean)) }
+    def enabled?(feature)
+      @configuration[:enableAll] || @configuration[feature]
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.13.0
+  version: 0.13.1
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-11-30 00:00:00.000000000 Z
+date: 2023-12-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -157,7 +157,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.21
+rubygems_version: 3.4.22
 signing_key: 
 specification_version: 4
 summary: An opinionated language server for Ruby