rubocop 1.54.2 → 1.55.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b5aa0f1796446e72fc2559c5e0ba132c8b8e0e2f244c649e37c475f309911cab
-  data.tar.gz: ab9d4c1160f25912df7db584e67e4c2ce13f8372823a8f5f732ca6664ea63863
+  metadata.gz: 7bfd5d73e8097398116fc389fa55f96eca51b61c95a5e9e4654d7eeebaeef985
+  data.tar.gz: a2cf8206a9896953e85516ebdc00f673a5852eb9613e877fee6b43058f7ef080
 SHA512:
-  metadata.gz: b314533429676735ccfbda5f7e891087c7c277fc84789aa4c82c6961ab966f8d7c6ce1c491f0b6033a7893c48348eebff092dc50f462dd5b3a3cbe77954adf99
-  data.tar.gz: 91e2894b3931bed08640afc882785b5e18371d79fee3a1f4a9eddcb44faa9c4b2232fe798185fcb2b57c3b4561efab25ac019ae543fa4c9b0bdaf0f8a361522b
+  metadata.gz: 454b6be8363e0a91226348e2543587d5e6c3503bdaa9b2c0287f1a1e347f9a315c8f8337c5762e59f83f7406a797645ebef7e16a896694da29cb751a658e5579
+  data.tar.gz: 388fe4a1934bf7659148ce32a2837f5ff0822babc1e17abd1a2c4f8138e6a839a7c4f304202e7e712763dbc23fadee4c92412554cbe699a8f81810e602d62f49

data/README.md

@@ -53,7 +53,7 @@ To prevent an unwanted RuboCop update you might want to use a conservative versi
 in your `Gemfile`:
 
 ```rb
-gem 'rubocop', '~> 1.54', require: false
+gem 'rubocop', '~> 1.55', require: false
 ```
 
 See [our versioning policy](https://docs.rubocop.org/rubocop/versioning.html) for further details.
@@ -67,6 +67,8 @@ $ cd my/cool/ruby/project
 $ rubocop
 ```
 
+You can also use this magic in your favorite editor with RuboCop's [built-in LSP](https://docs.rubocop.org/rubocop/usage/lsp.html).
+
 ## Documentation
 
 You can read a lot more about RuboCop in its [official docs](https://docs.rubocop.org).

data/config/default.yml

@@ -3072,6 +3072,7 @@ Style/ArgumentsForwarding:
   StyleGuide: '#arguments-forwarding'
   Enabled: pending
   AllowOnlyRestArgument: true
+  UseAnonymousForwarding: true
   VersionAdded: '1.1'
 
 Style/ArrayCoercion:
@@ -3916,8 +3917,9 @@ Style/HashConversion:
   Description: 'Avoid Hash[] in favor of ary.to_h or literal hashes.'
   StyleGuide: '#avoid-hash-constructor'
   Enabled: pending
+  SafeAutoCorrect: false
   VersionAdded: '1.10'
-  VersionChanged: '1.11'
+  VersionChanged: '1.55'
   AllowSplatArgument: true
 
 Style/HashEachMethods:
@@ -4810,12 +4812,16 @@ Style/RedundantArgument:
   Enabled: pending
   Safe: false
   VersionAdded: '1.4'
-  VersionChanged: '1.40'
+  VersionChanged: '1.55'
   Methods:
     # Array#join
     join: ''
     # Array#sum
     sum: 0
+    # Kernel.#exit
+    exit: true
+    # Kernel.#exit!
+    exit!: false
     # String#split
     split: ' '
     # String#chomp

data/config/obsoletion.yml

@@ -224,6 +224,11 @@ changed_parameters:
       - AllowedMethods
       - AllowedPatterns
     severity: warning
+  - cops: Style/ArgumentsForwarding
+    parameters: AllowOnlyRestArgument
+    reason: "`AllowOnlyRestArgument` has no effect with TargetRubyVersion >= 3.2."
+    severity: warning
+    minimum_ruby_version: 3.2
 
 # Enforced styles that have been removed or replaced
 changed_enforced_styles:

data/lib/rubocop/config_obsoletion/parameter_rule.rb

@@ -19,7 +19,7 @@ module RuboCop
       end
 
       def violated?
-        config[cop]&.key?(parameter)
+        applies_to_current_ruby_version? && config[cop]&.key?(parameter)
       end
 
       def warning?
@@ -28,6 +28,14 @@ module RuboCop
 
       private
 
+      def applies_to_current_ruby_version?
+        minimum_ruby_version = metadata['minimum_ruby_version']
+
+        return true unless minimum_ruby_version
+
+        config.target_ruby_version >= minimum_ruby_version
+      end
+
       def alternative
         metadata['alternative']
       end

data/lib/rubocop/cop/generator/require_file_injector.rb

@@ -67,7 +67,7 @@ module RuboCop
 
         def require_path
           path = source_path.relative_path_from(root_file_path.dirname)
-          path.to_s.sub('.rb', '')
+          path.to_s.delete_suffix('.rb')
         end
       end
     end

data/lib/rubocop/cop/layout/redundant_line_break.rb

@@ -48,6 +48,10 @@ module RuboCop
 
         MSG = 'Redundant line break detected.'
 
+        def on_lvasgn(node)
+          super unless end_with_percent_blank_string?(processed_source)
+        end
+
         def on_send(node)
           # Include "the whole expression".
           node = node.parent while node.parent&.send_type? ||
@@ -61,6 +65,10 @@ module RuboCop
 
         private
 
+        def end_with_percent_blank_string?(processed_source)
+          processed_source.buffer.source.end_with?("%\n\n")
+        end
+
         def check_assignment(node, _rhs)
           return unless offense?(node)
 

data/lib/rubocop/cop/lint/shadowing_outer_local_variable.rb

@@ -68,7 +68,7 @@ module RuboCop
 
         def same_conditions_node_different_branch?(variable, outer_local_variable)
           variable_node = variable_node(variable)
-          return false unless variable_node.conditional?
+          return false unless node_or_its_ascendant_conditional?(variable_node)
 
           outer_local_variable_node =
             find_conditional_node_from_ascendant(outer_local_variable.declaration_node)
@@ -96,6 +96,12 @@ module RuboCop
 
           find_conditional_node_from_ascendant(parent)
         end
+
+        def node_or_its_ascendant_conditional?(node)
+          return true if node.conditional?
+
+          !!find_conditional_node_from_ascendant(node)
+        end
       end
     end
   end

data/lib/rubocop/cop/mixin/string_help.rb

@@ -30,8 +30,8 @@ module RuboCop
       private
 
       def inside_interpolation?(node)
-        # A :begin node inside a :dstr node is an interpolation.
-        node.ancestors.drop_while { |a| !a.begin_type? }.any?(&:dstr_type?)
+        # A :begin node inside a :dstr or :dsym node is an interpolation.
+        node.ancestors.drop_while { |a| !a.begin_type? }.any? { |a| a.dstr_type? || a.dsym_type? }
       end
     end
   end

data/lib/rubocop/cop/style/arguments_forwarding.rb

@@ -8,6 +8,12 @@ module RuboCop
       # This cop identifies places where `do_something(*args, &block)`
       # can be replaced by `do_something(...)`.
       #
+      # In Ruby 3.2, anonymous args/kwargs forwarding has been added.
+      #
+      # This cop also identifies places where `use_args(*args)`/`use_kwargs(**kwargs)` can be
+      # replaced by `use_args(*)`/`use_kwargs(**)`; if desired, this functionality can be disabled
+      # by setting UseAnonymousForwarding: false.
+      #
       # @example
       #   # bad
       #   def foo(*args, &block)
@@ -24,7 +30,27 @@ module RuboCop
       #     bar(...)
       #   end
       #
-      # @example AllowOnlyRestArgument: true (default)
+      # @example UseAnonymousForwarding: true (default, only relevant for Ruby >= 3.2)
+      #   # bad
+      #   def foo(*args, **kwargs)
+      #     args_only(*args)
+      #     kwargs_only(**kwargs)
+      #   end
+      #
+      #   # good
+      #   def foo(*, **)
+      #     args_only(*)
+      #     kwargs_only(**)
+      #   end
+      #
+      # @example UseAnonymousForwarding: false (only relevant for Ruby >= 3.2)
+      #   # good
+      #   def foo(*args, **kwargs)
+      #     args_only(*args)
+      #     kwargs_only(**kwargs)
+      #   end
+      #
+      # @example AllowOnlyRestArgument: true (default, only relevant for Ruby < 3.2)
       #   # good
       #   def foo(*args)
       #     bar(*args)
@@ -34,7 +60,7 @@ module RuboCop
       #     bar(**kwargs)
       #   end
       #
-      # @example AllowOnlyRestArgument: false
+      # @example AllowOnlyRestArgument: false (only relevant for Ruby < 3.2)
       #   # bad
       #   # The following code can replace the arguments with `...`,
       #   # but it will change the behavior. Because `...` forwards block also.
@@ -53,77 +79,133 @@ module RuboCop
 
         minimum_target_ruby_version 2.7
 
-        MSG = 'Use arguments forwarding.'
-
-        # @!method use_rest_arguments?(node)
-        def_node_matcher :use_rest_arguments?, <<~PATTERN
-          (args ({restarg kwrestarg} $_) $...)
-        PATTERN
-
-        # @!method only_rest_arguments?(node, name)
-        def_node_matcher :only_rest_arguments?, <<~PATTERN
-          {
-            (send _ _ (splat (lvar %1)))
-            (send _ _ (hash (kwsplat (lvar %1))))
-          }
-        PATTERN
-
-        # @!method forwarding_method_arguments?(node, rest_name, block_name, kwargs_name)
-        def_node_matcher :forwarding_method_arguments?, <<~PATTERN
-          {
-            (send _ _
-              (splat (lvar %1))
-              (block-pass {(lvar %2) nil?}))
-            (send _ _
-              (splat (lvar %1))
-              (hash (kwsplat (lvar %3)))
-              (block-pass {(lvar %2) nil?}))
-          }
-        PATTERN
+        FORWARDING_LVAR_TYPES = %i[splat kwsplat block_pass].freeze
+
+        FORWARDING_MSG = 'Use shorthand syntax `...` for arguments forwarding.'
+        ARGS_MSG = 'Use anonymous positional arguments forwarding (`*`).'
+        KWARGS_MSG = 'Use anonymous keyword arguments forwarding (`**`).'
 
         def on_def(node)
           return unless node.body
-          return unless (rest_args_name, args = use_rest_arguments?(node.arguments))
-          return if args.any?(&:default?)
 
-          node.each_descendant(:send) do |send_node|
-            kwargs_name, block_name = extract_argument_names_from(args)
+          forwardable_args = extract_forwardable_args(node.arguments)
+
+          send_classifications = classify_send_nodes(
+            node,
+            node.each_descendant(:send).to_a,
+            non_splat_or_block_pass_lvar_references(node.body),
+            forwardable_args
+          )
 
-            next unless forwarding_method?(send_node, rest_args_name, kwargs_name, block_name) &&
-                        all_lvars_as_forwarding_method_arguments?(node, send_node)
+          return if send_classifications.empty?
 
-            register_offense_to_forwarding_method_arguments(send_node)
-            register_offense_to_method_definition_arguments(node)
+          if only_forwards_all?(send_classifications)
+            add_forward_all_offenses(node, send_classifications)
+          elsif target_ruby_version >= 3.2
+            add_post_ruby_32_offenses(node, send_classifications, forwardable_args)
           end
         end
+
         alias on_defs on_def
 
         private
 
-        def extract_argument_names_from(args)
-          kwargs_name = args.first.source.delete('**') if args.first&.kwrestarg_type?
-          block_arg_name = args.last.source.delete('&') if args.last&.blockarg_type?
+        def extract_forwardable_args(args)
+          [args.find(&:restarg_type?), args.find(&:kwrestarg_type?), args.find(&:blockarg_type?)]
+        end
+
+        def only_forwards_all?(send_classifications)
+          send_classifications.each_value.all? { |c, _, _| c == :all }
+        end
+
+        def add_forward_all_offenses(node, send_classifications)
+          send_classifications.each_key do |send_node|
+            register_forward_all_offense_on_forwarding_method(send_node)
+          end
+
+          register_forward_all_offense_on_method_def(node)
+        end
+
+        def add_post_ruby_32_offenses(def_node, send_classifications, forwardable_args)
+          return unless use_anonymous_forwarding?
+
+          rest_arg, kwrest_arg, _block_arg = *forwardable_args
+
+          send_classifications.each do |send_node, (_c, forward_rest, forward_kwrest)|
+            if forward_rest
+              register_forward_args_offense(def_node.arguments, rest_arg)
+              register_forward_args_offense(send_node, forward_rest)
+            end
 
-          [kwargs_name, block_arg_name].map { |name| name&.to_sym }
+            if forward_kwrest
+              register_forward_kwargs_offense(!forward_rest, def_node.arguments, kwrest_arg)
+              register_forward_kwargs_offense(!forward_rest, send_node, forward_kwrest)
+            end
+          end
         end
 
-        def forwarding_method?(node, rest_arg, kwargs, block_arg)
-          return only_rest_arguments?(node, rest_arg) unless allow_only_rest_arguments?
+        def non_splat_or_block_pass_lvar_references(body)
+          body.each_descendant(:lvar, :lvasgn).filter_map do |lvar|
+            parent = lvar.parent
+
+            next if lvar.lvar_type? && FORWARDING_LVAR_TYPES.include?(parent.type)
 
-          forwarding_method_arguments?(node, rest_arg, block_arg, kwargs)
+            lvar.children.first
+          end.uniq
         end
 
-        def all_lvars_as_forwarding_method_arguments?(def_node, forwarding_method)
-          lvars = def_node.body.each_descendant(:lvar, :lvasgn)
+        def classify_send_nodes(def_node, send_nodes, referenced_lvars, forwardable_args)
+          send_nodes.to_h do |send_node|
+            classification_and_forwards = classification_and_forwards(
+              def_node,
+              send_node,
+              referenced_lvars,
+              forwardable_args
+            )
+
+            [send_node, classification_and_forwards]
+          end.compact
+        end
 
-          begin_pos = forwarding_method.source_range.begin_pos
-          end_pos = forwarding_method.source_range.end_pos
+        def classification_and_forwards(def_node, send_node, referenced_lvars, forwardable_args)
+          classifier = SendNodeClassifier.new(
+            def_node,
+            send_node,
+            referenced_lvars,
+            forwardable_args,
+            target_ruby_version: target_ruby_version,
+            allow_only_rest_arguments: allow_only_rest_arguments?
+          )
 
-          lvars.all? { |lvar| lvar.source_range.begin_pos.between?(begin_pos, end_pos) }
+          classification = classifier.classification
+
+          return unless classification
+
+          [classification, classifier.forwarded_rest_arg, classifier.forwarded_kwrest_arg]
         end
 
-        def register_offense_to_forwarding_method_arguments(forwarding_method)
-          add_offense(arguments_range(forwarding_method)) do |corrector|
+        def register_forward_args_offense(def_arguments_or_send, rest_arg_or_splat)
+          add_offense(rest_arg_or_splat, message: ARGS_MSG) do |corrector|
+            unless parentheses?(def_arguments_or_send)
+              add_parentheses(def_arguments_or_send, corrector)
+            end
+
+            corrector.replace(rest_arg_or_splat, '*')
+          end
+        end
+
+        def register_forward_kwargs_offense(add_parens, def_arguments_or_send, kwrest_arg_or_splat)
+          add_offense(kwrest_arg_or_splat, message: KWARGS_MSG) do |corrector|
+            if add_parens && !parentheses?(def_arguments_or_send)
+              add_parentheses(def_arguments_or_send, corrector)
+            end
+
+            corrector.replace(kwrest_arg_or_splat, '**')
+          end
+        end
+
+        def register_forward_all_offense_on_forwarding_method(forwarding_method)
+          add_offense(arguments_range(forwarding_method), message: FORWARDING_MSG) do |corrector|
             begin_pos = forwarding_method.loc.selector&.end_pos || forwarding_method.loc.dot.end_pos
             range = range_between(begin_pos, forwarding_method.source_range.end_pos)
 
@@ -131,8 +213,8 @@ module RuboCop
           end
         end
 
-        def register_offense_to_method_definition_arguments(method_definition)
-          add_offense(arguments_range(method_definition)) do |corrector|
+        def register_forward_all_offense_on_method_def(method_definition)
+          add_offense(arguments_range(method_definition), message: FORWARDING_MSG) do |corrector|
             arguments_range = range_with_surrounding_space(
               method_definition.arguments.source_range, side: :left
             )
@@ -149,6 +231,97 @@ module RuboCop
         def allow_only_rest_arguments?
           cop_config.fetch('AllowOnlyRestArgument', true)
         end
+
+        def use_anonymous_forwarding?
+          cop_config.fetch('UseAnonymousForwarding', false)
+        end
+
+        # Classifies send nodes for possible rest/kwrest/all (including block) forwarding.
+        class SendNodeClassifier
+          extend NodePattern::Macros
+
+          # @!method find_forwarded_rest_arg(node, rest_name)
+          def_node_search :find_forwarded_rest_arg, '(splat (lvar %1))'
+
+          # @!method find_forwarded_kwrest_arg(node, kwrest_name)
+          def_node_search :find_forwarded_kwrest_arg, '(kwsplat (lvar %1))'
+
+          # @!method find_forwarded_block_arg(node, block_name)
+          def_node_search :find_forwarded_block_arg, '(block_pass {(lvar %1) nil?})'
+
+          def initialize(def_node, send_node, referenced_lvars, forwardable_args, **config)
+            @def_node = def_node
+            @send_node = send_node
+            @referenced_lvars = referenced_lvars
+            @rest_arg, @kwrest_arg, @block_arg = *forwardable_args
+            @rest_arg_name, @kwrest_arg_name, @block_arg_name =
+              *forwardable_args.map { |a| a&.name }
+            @config = config
+          end
+
+          def forwarded_rest_arg
+            return nil if referenced_rest_arg?
+
+            find_forwarded_rest_arg(@send_node, @rest_arg_name).first
+          end
+
+          def forwarded_kwrest_arg
+            return nil if referenced_kwrest_arg?
+
+            find_forwarded_kwrest_arg(@send_node, @kwrest_arg_name).first
+          end
+
+          def forwarded_block_arg
+            return nil if referenced_block_arg?
+
+            find_forwarded_block_arg(@send_node, @block_arg_name).first
+          end
+
+          def classification
+            return nil unless forwarded_rest_arg || forwarded_kwrest_arg
+
+            if referenced_none? && (forwarded_exactly_all? || pre_ruby_32_allow_forward_all?)
+              :all
+            elsif target_ruby_version >= 3.2
+              :rest_or_kwrest
+            end
+          end
+
+          private
+
+          def referenced_rest_arg?
+            @referenced_lvars.include?(@rest_arg_name)
+          end
+
+          def referenced_kwrest_arg?
+            @referenced_lvars.include?(@kwrest_arg_name)
+          end
+
+          def referenced_block_arg?
+            @referenced_lvars.include?(@block_arg_name)
+          end
+
+          def referenced_none?
+            !(referenced_rest_arg? || referenced_kwrest_arg? || referenced_block_arg?)
+          end
+
+          def forwarded_exactly_all?
+            @send_node.arguments.size == 3 &&
+              forwarded_rest_arg &&
+              forwarded_kwrest_arg &&
+              forwarded_block_arg
+          end
+
+          def target_ruby_version
+            @config.fetch(:target_ruby_version)
+          end
+
+          def pre_ruby_32_allow_forward_all?
+            target_ruby_version < 3.2 &&
+              @def_node.arguments.none?(&:default?) &&
+              (@block_arg ? forwarded_block_arg : !@config.fetch(:allow_only_rest_arguments))
+          end
+        end
       end
     end
   end

data/lib/rubocop/cop/style/combinable_loops.rb

@@ -67,6 +67,7 @@ module RuboCop
           return unless node.parent&.begin_type?
           return unless collection_looping_method?(node)
           return unless same_collection_looping_block?(node, node.left_sibling)
+          return unless node.body && node.left_sibling.body
 
           add_offense(node) do |corrector|
             combine_with_left_sibling(corrector, node)

data/lib/rubocop/cop/style/hash_conversion.rb

@@ -10,6 +10,16 @@ module RuboCop
       # `Hash[*ary]` can be replaced with `ary.each_slice(2).to_h` but it will be complicated.
       # So, `AllowSplatArgument` option is true by default to allow splat argument for simple code.
       #
+      # @safety
+      #   This cop's autocorrection is unsafe because `ArgumentError` occurs
+      #   if the number of elements is odd:
+      #
+      #   [source,ruby]
+      #   ----
+      #   Hash[[[1, 2], [3]]] #=> {1=>2, 3=>nil}
+      #   [[1, 2], [5]].to_h  #=> wrong array length at 1 (expected 2, was 1) (ArgumentError)
+      #   ----
+      #
       # @example
       #   # bad
       #   Hash[ary]

data/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb

@@ -124,9 +124,10 @@ module RuboCop
             node.parent&.class_type? && node.parent&.single_line?
           end
 
-          def call_with_ambiguous_arguments?(node)
+          def call_with_ambiguous_arguments?(node) # rubocop:disable Metrics/PerceivedComplexity
             call_with_braced_block?(node) ||
               call_as_argument_or_chain?(node) ||
+              call_in_match_pattern?(node) ||
               hash_literal_in_arguments?(node) ||
               node.descendants.any? do |n|
                 n.forwarded_args_type? || ambiguous_literal?(n) || logical_operator?(n) ||
@@ -144,6 +145,10 @@ module RuboCop
               node.parent.csend_type? || node.parent.super_type? || node.parent.yield_type?)
           end
 
+          def call_in_match_pattern?(node)
+            node.parent&.match_pattern_type?
+          end
+
           def hash_literal_in_arguments?(node)
             node.arguments.any? do |n|
               hash_literal?(n) ||

data/lib/rubocop/cop/style/redundant_argument.rb

@@ -35,6 +35,8 @@ module RuboCop
       #   array.join('')
       #   [1, 2, 3].join("")
       #   array.sum(0)
+      #   exit(true)
+      #   exit!(false)
       #   string.split(" ")
       #   "first\nsecond".split(" ")
       #   string.chomp("\n")
@@ -45,6 +47,8 @@ module RuboCop
       #   array.join
       #   [1, 2, 3].join
       #   array.sum
+      #   exit
+      #   exit!
       #   string.split
       #   "first second".split
       #   string.chomp
@@ -55,9 +59,10 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Argument %<arg>s is redundant because it is implied by default.'
+        NO_RECEIVER_METHODS = %i[exit exit!].freeze
 
         def on_send(node)
-          return if node.receiver.nil?
+          return if !NO_RECEIVER_METHODS.include?(node.method_name) && node.receiver.nil?
           return if node.arguments.count != 1
           return unless redundant_argument?(node)
 

data/lib/rubocop/cop/style/return_nil_in_predicate_method_definition.rb

@@ -52,7 +52,7 @@ module RuboCop
         include AllowedMethods
         include AllowedPattern
 
-        MSG = 'Use `return false` instead of `%<prefer>s` in the predicate method.'
+        MSG = 'Return `false` instead of `nil` in predicate methods.'
 
         # @!method return_nil?(node)
         def_node_matcher :return_nil?, <<~PATTERN
@@ -65,16 +65,28 @@ module RuboCop
           return unless (body = node.body)
 
           body.each_descendant(:return) do |return_node|
-            next unless return_nil?(return_node)
+            register_offense(return_node, 'return false') if return_nil?(return_node)
+          end
 
-            message = format(MSG, prefer: return_node.source)
+          return unless (nil_node = nil_node_at_the_end_of_method_body(body))
 
-            add_offense(return_node, message: message) do |corrector|
-              corrector.replace(return_node, 'return false')
-            end
-          end
+          register_offense(nil_node, 'false')
         end
         alias on_defs on_def
+
+        private
+
+        def nil_node_at_the_end_of_method_body(body)
+          return unless (last_child = body.children.last)
+
+          last_child if last_child.is_a?(AST::Node) && last_child.nil_type?
+        end
+
+        def register_offense(offense_node, replacement)
+          add_offense(offense_node) do |corrector|
+            corrector.replace(offense_node, replacement)
+          end
+        end
       end
     end
   end

data/lib/rubocop/cop/style/symbol_array.rb

@@ -22,6 +22,15 @@ module RuboCop
       #   # bad
       #   [:foo, :bar, :baz]
       #
+      #   # bad (contains spaces)
+      #   %i[foo\ bar baz\ quux]
+      #
+      #   # bad (contains [] with spaces)
+      #   %i[foo \[ \]]
+      #
+      #   # bad (contains () with spaces)
+      #   %i(foo \( \))
+      #
       # @example EnforcedStyle: brackets
       #   # good
       #   [:foo, :bar, :baz]
@@ -40,6 +49,7 @@ module RuboCop
 
         PERCENT_MSG = 'Use `%i` or `%I` for an array of symbols.'
         ARRAY_MSG = 'Use %<prefer>s for an array of symbols.'
+        DELIMITERS = ['[', ']', '(', ')'].freeze
 
         class << self
           attr_accessor :largest_brackets
@@ -47,7 +57,7 @@ module RuboCop
 
         def on_array(node)
           if bracketed_array_of?(:sym, node)
-            return if symbols_contain_spaces?(node)
+            return if complex_content?(node)
 
             check_bracketed_array(node, 'i')
           elsif node.percent_literal?(:symbol)
@@ -57,13 +67,22 @@ module RuboCop
 
         private
 
-        def symbols_contain_spaces?(node)
+        def complex_content?(node)
           node.children.any? do |sym|
             content, = *sym
-            content.to_s.include?(' ')
+            content = content.to_s
+            content_without_delimiter_pairs = content.gsub(/(\[\])|(\(\))/, '')
+
+            content.include?(' ') || DELIMITERS.any? do |delimiter|
+              content_without_delimiter_pairs.include?(delimiter)
+            end
           end
         end
 
+        def invalid_percent_array_contents?(node)
+          complex_content?(node)
+        end
+
         def build_bracketed_array(node)
           return '[]' if node.children.empty?
 

data/lib/rubocop/formatter/junit_formatter.rb

@@ -63,7 +63,7 @@ module RuboCop
 
       def classname_attribute_value(file)
         @classname_attribute_value_cache ||= Hash.new do |hash, key|
-          hash[key] = key.gsub(/\.rb\Z/, '').gsub("#{Dir.pwd}/", '').tr('/', '.')
+          hash[key] = key.delete_suffix('.rb').gsub("#{Dir.pwd}/", '').tr('/', '.')
         end
         @classname_attribute_value_cache[file]
       end

data/lib/rubocop/lsp/routes.rb

@@ -36,7 +36,9 @@ module RuboCop
       end
 
       handle 'initialize' do |request|
-        @server.configure(safe_autocorrect: safe_autocorrect?(request))
+        initialization_options = extract_initialization_options_from(request)
+
+        @server.configure(initialization_options)
 
         @server.write(
           id: request[:id],
@@ -164,10 +166,14 @@ module RuboCop
 
       private
 
-      def safe_autocorrect?(request)
+      def extract_initialization_options_from(request)
         safe_autocorrect = request.dig(:params, :initializationOptions, :safeAutocorrect)
 
-        safe_autocorrect.nil? || safe_autocorrect == true
+        {
+          safe_autocorrect: safe_autocorrect.nil? || safe_autocorrect == true,
+          lint_mode: request.dig(:params, :initializationOptions, :lintMode) == true,
+          layout_mode: request.dig(:params, :initializationOptions, :layoutMode) == true
+        }
       end
 
       def format_file(file_uri)

data/lib/rubocop/lsp/runtime.rb

@@ -14,12 +14,14 @@ module RuboCop
     # Runtime for Language Server Protocol of RuboCop.
     # @api private
     class Runtime
-      attr_writer :safe_autocorrect
+      attr_writer :safe_autocorrect, :lint_mode, :layout_mode
 
       def initialize(config_store)
         @config_store = config_store
         @logged_paths = []
         @safe_autocorrect = true
+        @lint_mode = false
+        @layout_mode = false
       end
 
       # This abuses the `--stdin` option of rubocop and reads the formatted text
@@ -37,6 +39,7 @@ module RuboCop
         formatting_options = {
           stdin: text, force_exclusion: true, autocorrect: true, safe_autocorrect: @safe_autocorrect
         }
+        formatting_options[:only] = config_only_options if @lint_mode || @layout_mode
 
         redirect_stdout { run_rubocop(formatting_options, path) }
 
@@ -47,6 +50,7 @@ module RuboCop
         diagnostic_options = {
           stdin: text, force_exclusion: true, formatters: ['json'], format: 'json'
         }
+        diagnostic_options[:only] = config_only_options if @lint_mode || @layout_mode
 
         json = redirect_stdout { run_rubocop(diagnostic_options, path) }
         results = JSON.parse(json, symbolize_names: true)
@@ -64,6 +68,13 @@ module RuboCop
 
       private
 
+      def config_only_options
+        only_options = []
+        only_options << 'Lint' if @lint_mode
+        only_options << 'Layout' if @layout_mode
+        only_options
+      end
+
       def redirect_stdout(&block)
         stdout = StringIO.new
 

data/lib/rubocop/lsp/server.rb

@@ -53,8 +53,10 @@ module RuboCop
         @runtime.offenses(path, text)
       end
 
-      def configure(safe_autocorrect: true)
-        @runtime.safe_autocorrect = safe_autocorrect
+      def configure(options)
+        @runtime.safe_autocorrect = options[:safe_autocorrect]
+        @runtime.lint_mode = options[:lint_mode]
+        @runtime.layout_mode = options[:layout_mode]
       end
 
       def stop(&block)

data/lib/rubocop/result_cache.rb

@@ -202,6 +202,10 @@ module RuboCop
       lib_root = File.join(File.dirname(__FILE__), '..')
       exe_root = File.join(lib_root, '..', 'exe')
 
+      # Make sure to use an absolute path to prevent errors on Windows
+      # when traversing the relative paths with symlinks.
+      exe_root = File.absolute_path(exe_root)
+
       # These are all the files we have `require`d plus everything in the
       # exe directory. A change to any of them could affect the cop output
       # so we include them in the cache hash.

data/lib/rubocop/target_finder.rb

@@ -94,8 +94,12 @@ module RuboCop
     end
 
     def wanted_dir_patterns(base_dir, exclude_pattern, flags)
-      base_dir = base_dir.gsub('/{}/', '/\{}/')
-      dirs = Dir.glob(File.join(base_dir.gsub('/*/', '/\*/').gsub('/**/', '/\**/'), '*/'), flags)
+      # Escape glob characters in base_dir to avoid unwanted behavior.
+      base_dir = base_dir.gsub(/[\\\{\}\[\]\*\?]/) do |reserved_glob_character|
+        "\\#{reserved_glob_character}"
+      end
+
+      dirs = Dir.glob(File.join(base_dir, '*/'), flags)
                 .reject do |dir|
                   next true if dir.end_with?('/./', '/../')
                   next true if File.fnmatch?(exclude_pattern, dir, flags)

data/lib/rubocop/version.rb

@@ -3,7 +3,7 @@
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '1.54.2'
+    STRING = '1.55.0'
 
     MSG = '%<version>s (using Parser %<parser_version>s, ' \
           'rubocop-ast %<rubocop_ast_version>s, ' \

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop
 version: !ruby/object:Gem::Version
-  version: 1.54.2
+  version: 1.55.0
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-07-13 00:00:00.000000000 Z
+date: 2023-07-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -134,7 +134,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.28.0
+        version: 1.28.1
     - - "<"
       - !ruby/object:Gem::Version
         version: '2.0'
@@ -144,7 +144,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.28.0
+        version: 1.28.1
     - - "<"
       - !ruby/object:Gem::Version
         version: '2.0'
@@ -1023,7 +1023,7 @@ metadata:
   homepage_uri: https://rubocop.org/
   changelog_uri: https://github.com/rubocop/rubocop/blob/master/CHANGELOG.md
   source_code_uri: https://github.com/rubocop/rubocop/
-  documentation_uri: https://docs.rubocop.org/rubocop/1.54/
+  documentation_uri: https://docs.rubocop.org/rubocop/1.55/
   bug_tracker_uri: https://github.com/rubocop/rubocop/issues
   rubygems_mfa_required: 'true'
 post_install_message: