rubocop 1.61.0 → 1.62.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 506b140c491cce5d643f22ac7a58396d82f19162c8bc22b2741f67a551913b07
-  data.tar.gz: 51032873c1ce81903898c952ee828e6753a566faa204c7821f9d8a4cbbddf75d
+  metadata.gz: 8daa4ef7dd74b8608039d7dfda5f1e3fe739738949390a6f1347acaccf7bd1c4
+  data.tar.gz: 271a978db956def596a5b06a7fd69d189d807b27db0acdda03fd6200b95ef541
 SHA512:
-  metadata.gz: 1aa5ca182c9a0905f8b7c45408722a9885e0ac2ac104ed03e57386afa2c8323a0ce8489ed12abfcd7e169faaac428901a83d2301aa1fcaff2a84c1a2897d81f7
-  data.tar.gz: 3f6d87ac3565d097f962bb24fa6b8c32851e622548a7b603e2c801ef27e1002ff816ec25aff8e461799fa1ee897b875409919f67120c9f9c47e0a19c881f9840
+  metadata.gz: 484294f43781f114ba01470b22331ef17648219e26dc4ba2f28073f609c909af2997c47e1f1aad62860124f6f4594a2e536cd793f05352a78d588f979732a290
+  data.tar.gz: 6a8313e61422bcd568eea747c0f9a88f61f50620b4dd4f478da0bdd3e067c1aa8bcf70e15744e02118d4c525eb0632fae3cc19caf73db6db1f63ea76dbb84b45

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.61', require: false
+gem 'rubocop', '~> 1.62', require: false
 ```
 
 See [our versioning policy](https://docs.rubocop.org/rubocop/versioning.html) for further details.

data/config/default.yml

@@ -144,6 +144,12 @@ AllCops:
   # Ruby version is still unresolved, RuboCop will use the oldest officially
   # supported Ruby version (currently Ruby 2.7).
   TargetRubyVersion: ~
+  # You can specify the parser engine. There are two options available:
+  # - `parser_whitequark` ... https://github.com/whitequark/parser
+  # - `parser_prism` ... https://github.com/ruby/prism (`Prism::Translation::Parser`)
+  # By default, `parser` is used. For the `TargetRubyVersion` value, `parser` can be specified for versions `2.0` and above.
+  # `parser_prism` can be specified for versions `3.3` and above. `parser_prism` is faster but still considered experimental.
+  ParserEngine: parser_whitequark
   # Determines if a notification for extension libraries should be shown when
   # rubocop is run. Keys are the name of the extension, and values are an array
   # of gems in the Gemfile that the extension is suggested for, if not already

data/lib/rubocop/cli/command/auto_generate_config.rb

@@ -17,7 +17,10 @@ module RuboCop
 
         PHASE_1_OVERRIDDEN = '(skipped because the default Layout/LineLength:Max is overridden)'
         PHASE_1_DISABLED = '(skipped because Layout/LineLength is disabled)'
-        PHASE_1_SKIPPED = '(skipped because a list of cops is passed to the `--only` flag)'
+        PHASE_1_SKIPPED_ONLY_COPS =
+          '(skipped because a list of cops is passed to the `--only` flag)'
+        PHASE_1_SKIPPED_ONLY_EXCLUDE =
+          '(skipped because only excludes will be generated due to `--auto-gen-only-exclude` flag)'
 
         def run
           add_formatter
@@ -29,12 +32,14 @@ module RuboCop
         private
 
         def maybe_run_line_length_cop
-          if !line_length_enabled?(@config_store.for_pwd)
+          if only_exclude?
+            skip_line_length_cop(PHASE_1_SKIPPED_ONLY_EXCLUDE)
+          elsif !line_length_enabled?(@config_store.for_pwd)
             skip_line_length_cop(PHASE_1_DISABLED)
           elsif !same_max_line_length?(@config_store.for_pwd, ConfigLoader.default_configuration)
             skip_line_length_cop(PHASE_1_OVERRIDDEN)
           elsif options_has_only_flag?
-            skip_line_length_cop(PHASE_1_SKIPPED)
+            skip_line_length_cop(PHASE_1_SKIPPED_ONLY_COPS)
           else
             run_line_length_cop
           end
@@ -65,6 +70,10 @@ module RuboCop
           @options[:only]
         end
 
+        def only_exclude?
+          @options[:auto_gen_only_exclude]
+        end
+
         # Do an initial run with only Layout/LineLength so that cops that
         # depend on Layout/LineLength:Max get the correct value for that
         # parameter.

data/lib/rubocop/config.rb

@@ -244,6 +244,10 @@ module RuboCop
         end
     end
 
+    def parser_engine
+      @parser_engine ||= for_all_cops.fetch('ParserEngine', :parser_whitequark).to_sym
+    end
+
     def target_rails_version
       @target_rails_version ||=
         if for_all_cops['TargetRailsVersion']

data/lib/rubocop/cop/base.rb

@@ -232,6 +232,10 @@ module RuboCop
         @config.target_ruby_version
       end
 
+      def parser_engine
+        @config.parser_engine
+      end
+
       def target_rails_version
         @config.target_rails_version
       end
@@ -254,7 +258,7 @@ module RuboCop
 
       # There should be very limited reasons for a Cop to do it's own parsing
       def parse(source, path = nil)
-        ProcessedSource.new(source, target_ruby_version, path)
+        ProcessedSource.new(source, target_ruby_version, path, parser_engine: parser_engine)
       end
 
       # @api private

data/lib/rubocop/cop/gemspec/required_ruby_version.rb

@@ -76,7 +76,9 @@ module RuboCop
         PATTERN
 
         def on_new_investigation
-          add_global_offense(MISSING_MSG) unless required_ruby_version?(processed_source.ast)
+          return if processed_source.ast && required_ruby_version?(processed_source.ast)
+
+          add_global_offense(MISSING_MSG)
         end
 
         def on_send(node)

data/lib/rubocop/cop/internal_affairs/node_matcher_directive.rb

@@ -26,10 +26,18 @@ module RuboCop
         MSG = 'Precede `%<method>s` with a `@!method` YARD directive.'
         MSG_WRONG_NAME = '`@!method` YARD directive has invalid method name, ' \
                          'use `%<expected>s` instead of `%<actual>s`.'
+        MSG_MISSING_SCOPE_SELF = 'Follow the `@!method` YARD directive with ' \
+                                 '`@!scope class` if it is a class method.'
+        MSG_WRONG_SCOPE_SELF = 'Do not use the `@!scope class` YARD directive if it ' \
+                               'is not a class method.'
         MSG_TOO_MANY = 'Multiple `@!method` YARD directives found for this matcher.'
 
         RESTRICT_ON_SEND = %i[def_node_matcher def_node_search].to_set.freeze
-        REGEXP = /^\s*#\s*@!method\s+(?<method_name>[a-z0-9_]+[?!]?)(?:\((?<args>.*)\))?/.freeze
+        REGEXP_METHOD = /
+          ^\s*\#\s*
+          @!method\s+(?<receiver>self\.)?(?<method_name>[a-z0-9_]+[?!]?)(?:\((?<args>.*)\))?
+        /x.freeze
+        REGEXP_SCOPE = /^\s*\#\s*@!scope class/.freeze
 
         # @!method pattern_matcher?(node)
         def_node_matcher :pattern_matcher?, <<~PATTERN
@@ -40,14 +48,15 @@ module RuboCop
           return if node.arguments.none?
           return unless valid_method_name?(node)
 
-          actual_name = node.first_argument.value
+          actual_name = node.first_argument.value.to_s
+
+          # Ignore cases where the method has a receiver that isn't self
+          return if actual_name.include?('.') && !actual_name.start_with?('self.')
+
           directives = method_directives(node)
           return too_many_directives(node) if directives.size > 1
 
-          directive = directives.first
-          return if directive_correct?(directive, actual_name)
-
-          register_offense(node, directive, actual_name)
+          process_directive(node, actual_name, directives.first)
         end
 
         private
@@ -58,44 +67,112 @@ module RuboCop
 
         def method_directives(node)
           comments = processed_source.ast_with_comments[node]
-
-          comments.filter_map do |comment|
-            match = comment.text.match(REGEXP)
+          group_comments(comments).filter_map do |comment_method, comment_scope|
+            match = comment_method.text.match(REGEXP_METHOD)
             next unless match
 
-            { node: comment, method_name: match[:method_name], args: match[:args] }
+            {
+              node_method: comment_method,
+              node_scope: comment_scope,
+              method_name: match[:method_name],
+              args: match[:args],
+              receiver: match[:receiver],
+              has_scope_directive: comment_scope&.text&.match?(REGEXP_SCOPE)
+            }
+          end
+        end
+
+        def group_comments(comments)
+          result = []
+          comments.each.with_index do |comment, index|
+            # Grab the scope directive if it is preceded by a method directive
+            if comment.text.include?('@!method')
+              result << if (next_comment = comments[index + 1])&.text&.include?('@!scope')
+                          [comment, next_comment]
+                        else
+                          [comment, nil]
+                        end
+            end
           end
+          result
         end
 
         def too_many_directives(node)
           add_offense(node, message: MSG_TOO_MANY)
         end
 
-        def directive_correct?(directive, actual_name)
-          directive && directive[:method_name] == actual_name.to_s
+        def process_directive(node, actual_name, directive)
+          return unless (offense_type = directive_offense_type(directive, actual_name))
+
+          register_offense(offense_type, node, directive, actual_name)
+        end
+
+        def directive_offense_type(directive, actual_name)
+          return :missing_directive unless directive
+
+          return :wrong_scope if wrong_scope(directive, actual_name)
+          return :no_scope if no_scope(directive, actual_name)
+
+          # The method directive being prefixed by 'self.' is always an offense.
+          # The matched method_name does not contain the receiver but the
+          # def_node_match method name may so it must be removed.
+          if directive[:method_name] != remove_receiver(actual_name) || directive[:receiver]
+            :wrong_name
+          end
+        end
+
+        def wrong_scope(directive, actual_name)
+          !actual_name.start_with?('self.') && directive[:has_scope_directive]
+        end
+
+        def no_scope(directive, actual_name)
+          actual_name.start_with?('self.') && !directive[:has_scope_directive]
         end
 
-        def register_offense(node, directive, actual_name)
-          message = formatted_message(directive, actual_name, node.method_name)
+        def register_offense(offense_type, node, directive, actual_name)
+          message = formatted_message(offense_type, directive, actual_name, node.method_name)
 
           add_offense(node, message: message) do |corrector|
-            if directive
-              correct_directive(corrector, directive, actual_name)
-            else
-              insert_directive(corrector, node, actual_name)
+            case offense_type
+            when :wrong_name
+              correct_method_directive(corrector, directive, actual_name)
+            when :wrong_scope
+              remove_scope_directive(corrector, directive)
+            when :no_scope
+              insert_scope_directive(corrector, directive[:node_method])
+            when :missing_directive
+              insert_method_directive(corrector, node, actual_name)
             end
           end
         end
 
-        def formatted_message(directive, actual_name, method_name)
-          if directive
-            format(MSG_WRONG_NAME, expected: actual_name, actual: directive[:method_name])
-          else
+        # rubocop:disable Metrics/MethodLength
+        def formatted_message(offense_type, directive, actual_name, method_name)
+          case offense_type
+          when :wrong_name
+            # Add the receiver to the name when showing an offense
+            current_name = if directive[:receiver]
+                             directive[:receiver] + directive[:method_name]
+                           else
+                             directive[:method_name]
+                           end
+            # The correct name will never include a receiver, remove it
+            format(MSG_WRONG_NAME, expected: remove_receiver(actual_name), actual: current_name)
+          when :wrong_scope
+            MSG_WRONG_SCOPE_SELF
+          when :no_scope
+            MSG_MISSING_SCOPE_SELF
+          when :missing_directive
             format(MSG, method: method_name)
           end
         end
+        # rubocop:enable Metrics/MethodLength
+
+        def remove_receiver(current)
+          current.delete_prefix('self.')
+        end
 
-        def insert_directive(corrector, node, actual_name)
+        def insert_method_directive(corrector, node, actual_name)
           # If the pattern matcher uses arguments (`%1`, `%2`, etc.), include them in the directive
           arguments = pattern_arguments(node.arguments[1].source)
 
@@ -107,6 +184,14 @@ module RuboCop
           corrector.insert_before(range, directive)
         end
 
+        def insert_scope_directive(corrector, node)
+          range = range_with_surrounding_space(node.source_range, side: :left, newlines: false)
+          indentation = range.source.match(/^\s*/)[0]
+          directive = "\n#{indentation}# @!scope class"
+
+          corrector.insert_after(node, directive)
+        end
+
         def pattern_arguments(pattern)
           arguments = %w[node]
           max_pattern_var = pattern.scan(/(?<=%)\d+/).map(&:to_i).max
@@ -134,12 +219,21 @@ module RuboCop
           end
         end
 
-        def correct_directive(corrector, directive, actual_name)
-          correct = "@!method #{actual_name}"
-          regexp = /@!method\s+#{Regexp.escape(directive[:method_name])}/
+        def correct_method_directive(corrector, directive, actual_name)
+          correct = "@!method #{remove_receiver(actual_name)}"
+          current_name = (directive[:receiver] || '') + directive[:method_name]
+          regexp = /@!method\s+#{Regexp.escape(current_name)}/
+
+          replacement = directive[:node_method].text.gsub(regexp, correct)
+          corrector.replace(directive[:node_method], replacement)
+        end
 
-          replacement = directive[:node].text.gsub(regexp, correct)
-          corrector.replace(directive[:node], replacement)
+        def remove_scope_directive(corrector, directive)
+          range = range_by_whole_lines(
+            directive[:node_scope].source_range,
+            include_final_newline: true
+          )
+          corrector.remove(range)
         end
       end
     end

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

@@ -27,9 +27,9 @@ module RuboCop
         MSG = 'Add an empty line after magic comments.'
 
         def on_new_investigation
-          return unless processed_source.ast &&
-                        (last_magic_comment = last_magic_comment(processed_source))
-          return if processed_source[last_magic_comment.loc.line].strip.empty?
+          return unless (last_magic_comment = last_magic_comment(processed_source))
+          return unless (next_line = processed_source[last_magic_comment.loc.line])
+          return if next_line.strip.empty?
 
           offending_range = offending_range(last_magic_comment)
 
@@ -46,18 +46,25 @@ module RuboCop
 
         # Find the last magic comment in the source file.
         #
-        # Take all comments that precede the first line of code, select the
+        # Take all comments that precede the first line of code (or just take
+        # them all in the case when there is no code), select the
         # magic comments, and return the last magic comment in the file.
         #
         # @return [Parser::Source::Comment] if magic comments exist before code
         # @return [nil] otherwise
         def last_magic_comment(source)
-          source
-            .comments
-            .take_while { |comment| comment.loc.line < source.ast.loc.line }
+          comments_before_code(source)
             .reverse
             .find { |comment| MagicComment.parse(comment.text).any? }
         end
+
+        def comments_before_code(source)
+          if source.ast
+            source.comments.take_while { |comment| comment.loc.line < source.ast.loc.line }
+          else
+            source.comments
+          end
+        end
       end
     end
   end

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

@@ -84,8 +84,14 @@ module RuboCop
         end
 
         def offense?(node)
-          node.multiline? && !too_long?(node) && suitable_as_single_line?(node) &&
-            !index_access_call_chained?(node) && !configured_to_not_be_inspected?(node)
+          return false if !node.multiline? || too_long?(node) || !suitable_as_single_line?(node)
+          return require_backslash?(node) if node.and_type? || node.or_type?
+
+          !index_access_call_chained?(node) && !configured_to_not_be_inspected?(node)
+        end
+
+        def require_backslash?(node)
+          processed_source.lines[node.loc.operator.line - 1].end_with?('\\')
         end
 
         def index_access_call_chained?(node)

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

@@ -116,7 +116,7 @@ module RuboCop
 
         def incorrect_style_detected(token1, token2,
                                      expect_space, is_empty_braces)
-          brace = (token1.text == '{' ? token1 : token2).pos
+          brace = (token1.left_brace? ? token1 : token2).pos
           range = expect_space ? brace : space_range(brace)
           detected_style = expect_space ? 'no_space' : 'space'
 

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

@@ -34,6 +34,7 @@ module RuboCop
         MSG_WITH_INDEX = 'Remove redundant `with_index`.'
 
         def on_block(node)
+          return unless node.receiver
           return unless (send = redundant_with_index?(node))
 
           range = with_index_range(send)

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

@@ -51,8 +51,13 @@ module RuboCop
           enum_conversion_call?(node) do |method_node, arguments|
             next if method_node.call_type? &&
                     !method_node.method?(:__method__) && !method_node.method?(:__callee__)
-            next if method_name?(method_node, def_node.method_name) &&
-                    arguments_match?(arguments, def_node)
+
+            valid = if method_name?(method_node, def_node.method_name)
+                      arguments_match?(arguments, def_node)
+                    else
+                      def_node.arguments.empty?
+                    end
+            return if valid
 
             add_offense(node)
           end

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

@@ -64,7 +64,7 @@ module RuboCop
             remove_node(corrector, node)
           elsif !proc_name.empty?
             autocorrect_block_pass(corrector, node, proc_name)
-          else
+          elsif node.block_type?
             autocorrect_block(corrector, node)
           end
         end

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

@@ -189,7 +189,7 @@ module RuboCop
         case node.type
         when :casgn   then _scope, _lhs, rhs = *node
         when :op_asgn then _lhs, _op, rhs = *node
-        when :send    then rhs = node.last_argument
+        when :send, :csend then rhs = node.last_argument
         else               _lhs, rhs = *node
         end
         rhs

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

@@ -54,9 +54,9 @@ module RuboCop
         end
 
         def on_send(node)
-          add_offense(
-            node.first_argument, message: format(MSG, class_var: node.first_argument.source)
-          )
+          return unless (first_argument = node.first_argument)
+
+          add_offense(first_argument, message: format(MSG, class_var: first_argument.source))
         end
       end
     end

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

@@ -66,6 +66,8 @@ module RuboCop
           return unless suspect_enumerable?(node)
 
           if style == :for
+            return unless node.receiver
+
             add_offense(node, message: PREFER_FOR) do |corrector|
               EachToForCorrector.new(node).call(corrector)
               opposite_style_detected

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

@@ -40,7 +40,7 @@ module RuboCop
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
         UNUSED_BLOCK_ARG_MSG = "#{MSG.chop} and remove the unused `%<unused_code>s` block argument."
-        ARRAY_CONVERTER_METHODS = %i[assoc flatten rassoc sort sort_by to_a].freeze
+        ARRAY_CONVERTER_METHODS = %i[assoc chunk flatten rassoc sort sort_by to_a].freeze
 
         # @!method kv_each(node)
         def_node_matcher :kv_each, <<~PATTERN

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

@@ -38,6 +38,7 @@ module RuboCop
 
         private
 
+        # rubocop:disable Metrics/AbcSize
         def autocorrect(corrector, node, begin_of_arguments)
           arguments = node.arguments
           joined_arguments = arguments.map(&:source).join(', ')
@@ -49,9 +50,17 @@ module RuboCop
             corrector.remove(range_by_whole_lines(arguments.loc.end, include_final_newline: true))
           end
 
-          corrector.remove(arguments_range(node))
+          arguments_range = arguments_range(node)
+          # If the method name isn't on the same line as def, move it directly after def
+          if arguments_range.first_line != opening_line(node)
+            corrector.remove(node.loc.name)
+            corrector.insert_after(node.loc.keyword, " #{node.loc.name.source}")
+          end
+
+          corrector.remove(arguments_range)
           corrector.insert_after(begin_of_arguments, joined_arguments)
         end
+        # rubocop:enable Metrics/AbcSize
 
         def last_line_source_of_arguments(arguments)
           processed_source[arguments.last_line - 1].strip

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

@@ -44,6 +44,8 @@ module RuboCop
         def_node_matcher :nil_check?, '(send _ :nil?)'
 
         def on_send(node)
+          return unless node.receiver
+
           style_check?(node) do
             add_offense(node.loc.selector) do |corrector|
               new_code = if prefer_comparison?

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

@@ -80,7 +80,7 @@ module RuboCop
 
         def correction_exploded_to_compact(node)
           exception_node, *message_nodes = *node.arguments
-          return node.source if message_nodes.size > 1
+          return if message_nodes.size > 1
 
           argument = message_nodes.first.source
           exception_class = exception_node.receiver&.source || exception_node.source

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

@@ -22,10 +22,11 @@ module RuboCop
 
         def on_send(node)
           return unless node.method?(:require_relative)
-          return unless node.first_argument.str_content&.start_with?(CURRENT_DIRECTORY_PATH)
-          return unless (index = node.first_argument.source.index(CURRENT_DIRECTORY_PATH))
+          return unless (first_argument = node.first_argument)
+          return unless first_argument.str_content&.start_with?(CURRENT_DIRECTORY_PATH)
+          return unless (index = first_argument.source.index(CURRENT_DIRECTORY_PATH))
 
-          begin_pos = node.first_argument.source_range.begin.begin_pos + index
+          begin_pos = first_argument.source_range.begin.begin_pos + index
           range = range_between(begin_pos, begin_pos + 2)
 
           add_offense(range) do |corrector|

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

@@ -72,7 +72,7 @@ module RuboCop
         ALLOWED_STRING_TOKENS = %i[tSTRING tSTRING_CONTENT].freeze
         ARGUMENT_TYPES = %i[
           kFALSE kNIL kSELF kTRUE tCONSTANT tCVAR tFLOAT tGVAR tIDENTIFIER tINTEGER tIVAR
-          tLBRACK tLCURLY tLPAREN_ARG tSTRING tSTRING_BEG tSYMBOL tXSTRING_BEG
+          tLABEL tLBRACK tLCURLY tLPAREN_ARG tSTRING tSTRING_BEG tSYMBOL tXSTRING_BEG
         ].freeze
 
         def on_new_investigation

data/lib/rubocop/cop/utils/regexp_ranges.rb

@@ -88,7 +88,7 @@ module RuboCop
         end
 
         def escaped_octal?(expr)
-          expr.text =~ /^\\[0-7]$/
+          expr.text.valid_encoding? && expr.text =~ /^\\[0-7]$/
         end
 
         def octal_digit?(char)

data/lib/rubocop/directive_comment.rb

@@ -6,9 +6,11 @@ module RuboCop
   # cops it contains.
   class DirectiveComment
     # @api private
-    REDUNDANT_DIRECTIVE_COP_DEPARTMENT = 'Lint'
+    LINT_DEPARTMENT = 'Lint'
     # @api private
-    REDUNDANT_DIRECTIVE_COP = "#{REDUNDANT_DIRECTIVE_COP_DEPARTMENT}/RedundantCopDisableDirective"
+    LINT_REDUNDANT_DIRECTIVE_COP = "#{LINT_DEPARTMENT}/RedundantCopDisableDirective"
+    # @api private
+    LINT_SYNTAX_COP = "#{LINT_DEPARTMENT}/Syntax"
     # @api private
     COP_NAME_PATTERN = '([A-Z]\w+/)*(?:[A-Z]\w+)'
     # @api private
@@ -118,9 +120,10 @@ module RuboCop
     end
 
     def parsed_cop_names
-      splitted_cops_string.map do |name|
+      cops = splitted_cops_string.map do |name|
         department?(name) ? cop_names_for_department(name) : name
       end.flatten
+      cops - [LINT_SYNTAX_COP]
     end
 
     def department?(name)
@@ -128,17 +131,16 @@ module RuboCop
     end
 
     def all_cop_names
-      exclude_redundant_directive_cop(cop_registry.names)
+      exclude_lint_department_cops(cop_registry.names)
     end
 
     def cop_names_for_department(department)
       names = cop_registry.names_for_department(department)
-      has_redundant_directive_cop = department == REDUNDANT_DIRECTIVE_COP_DEPARTMENT
-      has_redundant_directive_cop ? exclude_redundant_directive_cop(names) : names
+      department == LINT_DEPARTMENT ? exclude_lint_department_cops(names) : names
     end
 
-    def exclude_redundant_directive_cop(cops)
-      cops - [REDUNDANT_DIRECTIVE_COP]
+    def exclude_lint_department_cops(cops)
+      cops - [LINT_REDUNDANT_DIRECTIVE_COP, LINT_SYNTAX_COP]
     end
   end
 end

data/lib/rubocop/magic_comment.rb

@@ -268,7 +268,7 @@ module RuboCop
 
       # Rewrite the comment without a given token type
       def without(type)
-        if @comment.match?(/\A#\s*#{self.class::KEYWORDS[type.to_sym]}/)
+        if @comment.match?(/\A#\s*#{self.class::KEYWORDS[type.to_sym]}/io)
           ''
         else
           @comment

data/lib/rubocop/rspec/cop_helper.rb

@@ -6,7 +6,11 @@ require 'tempfile'
 module CopHelper
   extend RSpec::SharedContext
 
-  let(:ruby_version) { RuboCop::TargetRuby::DEFAULT_VERSION }
+  let(:ruby_version) do
+    # The minimum version Prism can parse is 3.3.
+    ENV['PARSER_ENGINE'] == 'parser_prism' ? 3.3 : RuboCop::TargetRuby::DEFAULT_VERSION
+  end
+  let(:parser_engine) { ENV.fetch('PARSER_ENGINE', :parser_whitequark).to_sym }
   let(:rails_version) { false }
 
   def inspect_source(source, file = nil)
@@ -28,7 +32,9 @@ module CopHelper
       file = file.path
     end
 
-    processed_source = RuboCop::ProcessedSource.new(source, ruby_version, file)
+    processed_source = RuboCop::ProcessedSource.new(
+      source, ruby_version, file, parser_engine: parser_engine
+    )
     processed_source.config = configuration
     processed_source.registry = registry
     processed_source

data/lib/rubocop/rspec/expect_offense.rb

@@ -126,7 +126,7 @@ module RuboCop
         @offenses
       end
 
-      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity
       def expect_correction(correction, loop: true, source: nil)
         if source
           expected_annotations = parse_annotations(source, raise_error: false)
@@ -148,7 +148,6 @@ module RuboCop
 
           break corrected_source unless loop
           break corrected_source if @last_corrector.empty?
-          break corrected_source if corrected_source == @processed_source.buffer.source
 
           if iteration > RuboCop::Runner::MAX_ITERATIONS
             raise RuboCop::Runner::InfiniteCorrectionLoop.new(@processed_source.path, [@offenses])
@@ -163,19 +162,20 @@ module RuboCop
 
         expect(new_source).to eq(correction)
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity
 
       def expect_no_corrections
         raise '`expect_no_corrections` must follow `expect_offense`' unless @processed_source
 
         return if @last_corrector.empty?
 
-        # In order to print a nice diff, e.g. what source got corrected to,
-        # we need to run the actual corrections
-
+        # This is just here for a pretty diff if the source actually got changed
         new_source = @last_corrector.rewrite
-
         expect(new_source).to eq(@processed_source.buffer.source)
+
+        # There is an infinite loop if a corrector is present that did not make
+        # any changes. It will cause the same offense/correction on the next loop.
+        raise RuboCop::Runner::InfiniteCorrectionLoop.new(@processed_source.path, [@offenses])
       end
 
       def expect_no_offenses(source, file = nil)
@@ -212,7 +212,7 @@ module RuboCop
 
       # Parsed representation of code annotated with the `^^^ Message` style
       class AnnotatedSource
-        ANNOTATION_PATTERN = /\A\s*(\^+|\^{}) /.freeze
+        ANNOTATION_PATTERN = /\A\s*(\^+|\^{}) ?/.freeze
         ABBREV = "[...]\n"
 
         # @param annotated_source [String] string passed to the matchers

data/lib/rubocop/rspec/shared_contexts.rb

@@ -139,49 +139,64 @@ RSpec.shared_context 'lsp' do
 end
 
 RSpec.shared_context 'ruby 2.0' do
-  let(:ruby_version) { 2.0 }
+  # Prism supports parsing Ruby 3.3+.
+  let(:ruby_version) { ENV['PARSER_ENGINE'] == 'parser_prism' ? 3.3 : 2.0 }
 end
 
 RSpec.shared_context 'ruby 2.1' do
-  let(:ruby_version) { 2.1 }
+  # Prism supports parsing Ruby 3.3+.
+  let(:ruby_version) { ENV['PARSER_ENGINE'] == 'parser_prism' ? 3.3 : 2.1 }
 end
 
 RSpec.shared_context 'ruby 2.2' do
-  let(:ruby_version) { 2.2 }
+  # Prism supports parsing Ruby 3.3+.
+  let(:ruby_version) { ENV['PARSER_ENGINE'] == 'parser_prism' ? 3.3 : 2.2 }
 end
 
 RSpec.shared_context 'ruby 2.3' do
-  let(:ruby_version) { 2.3 }
+  # Prism supports parsing Ruby 3.3+.
+  let(:ruby_version) { ENV['PARSER_ENGINE'] == 'parser_prism' ? 3.3 : 2.3 }
 end
 
 RSpec.shared_context 'ruby 2.4' do
-  let(:ruby_version) { 2.4 }
+  # Prism supports parsing Ruby 3.3+.
+  let(:ruby_version) { ENV['PARSER_ENGINE'] == 'parser_prism' ? 3.3 : 2.4 }
 end
 
 RSpec.shared_context 'ruby 2.5' do
-  let(:ruby_version) { 2.5 }
+  # Prism supports parsing Ruby 3.3+.
+  let(:ruby_version) { ENV['PARSER_ENGINE'] == 'parser_prism' ? 3.3 : 2.5 }
 end
 
 RSpec.shared_context 'ruby 2.6' do
-  let(:ruby_version) { 2.6 }
+  # Prism supports parsing Ruby 3.3+.
+  let(:ruby_version) { ENV['PARSER_ENGINE'] == 'parser_prism' ? 3.3 : 2.6 }
 end
 
 RSpec.shared_context 'ruby 2.7' do
-  let(:ruby_version) { 2.7 }
+  # Prism supports parsing Ruby 3.3+.
+  let(:ruby_version) { ENV['PARSER_ENGINE'] == 'parser_prism' ? 3.3 : 2.7 }
 end
 
 RSpec.shared_context 'ruby 3.0' do
-  let(:ruby_version) { 3.0 }
+  # Prism supports parsing Ruby 3.3+.
+  let(:ruby_version) { ENV['PARSER_ENGINE'] == 'parser_prism' ? 3.3 : 3.0 }
 end
 
 RSpec.shared_context 'ruby 3.1' do
-  let(:ruby_version) { 3.1 }
+  # Prism supports parsing Ruby 3.3+.
+  let(:ruby_version) { ENV['PARSER_ENGINE'] == 'parser_prism' ? 3.3 : 3.1 }
 end
 
 RSpec.shared_context 'ruby 3.2' do
-  let(:ruby_version) { 3.2 }
+  # Prism supports parsing Ruby 3.3+.
+  let(:ruby_version) { ENV['PARSER_ENGINE'] == 'parser_prism' ? 3.3 : 3.2 }
 end
 
 RSpec.shared_context 'ruby 3.3' do
   let(:ruby_version) { 3.3 }
 end
+
+RSpec.shared_context 'ruby 3.4' do
+  let(:ruby_version) { 3.4 }
+end

data/lib/rubocop/rspec/support.rb

@@ -27,4 +27,5 @@ RSpec.configure do |config|
   config.include_context 'ruby 3.1', :ruby31
   config.include_context 'ruby 3.2', :ruby32
   config.include_context 'ruby 3.3', :ruby33
+  config.include_context 'ruby 3.4', :ruby34
 end

data/lib/rubocop/runner.rb

@@ -467,15 +467,21 @@ module RuboCop
       end
     end
 
+    # rubocop:disable Metrics/MethodLength
     def get_processed_source(file)
       config = @config_store.for_file(file)
       ruby_version = config.target_ruby_version
+      parser_engine = config.parser_engine
 
       processed_source = if @options[:stdin]
-                           ProcessedSource.new(@options[:stdin], ruby_version, file)
+                           ProcessedSource.new(
+                             @options[:stdin], ruby_version, file, parser_engine: parser_engine
+                           )
                          else
                            begin
-                             ProcessedSource.from_file(file, ruby_version)
+                             ProcessedSource.from_file(
+                               file, ruby_version, parser_engine: parser_engine
+                             )
                            rescue Errno::ENOENT
                              raise RuboCop::Error, "No such file or directory: #{file}"
                            end
@@ -484,6 +490,7 @@ module RuboCop
       processed_source.registry = mobilized_cop_classes(config)
       processed_source
     end
+    # rubocop:enable Metrics/MethodLength
 
     # A Cop::Team instance is stateful and may change when inspecting.
     # The "standby" team for a given config is an initialized but

data/lib/rubocop/target_finder.rb

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 
 module RuboCop
-  # This class finds target files to inspect by scanning the directory tree
-  # and picking ruby files.
+  # This class finds target files to inspect by scanning the directory tree and picking ruby files.
   # @api private
   class TargetFinder
     HIDDEN_PATH_SUBSTRING = "#{File::SEPARATOR}."
@@ -12,21 +11,8 @@ module RuboCop
       @options = options
     end
 
-    def force_exclusion?
-      @options[:force_exclusion]
-    end
-
-    def debug?
-      @options[:debug]
-    end
-
-    def fail_fast?
-      @options[:fail_fast]
-    end
-
-    # Generate a list of target files by expanding globbing patterns
-    # (if any). If args is empty, recursively find all Ruby source
-    # files under the current directory
+    # Generate a list of target files by expanding globbing patterns (if any). If args is empty,
+    # recursively find all Ruby source files under the current directory
     # @return [Array] array of file paths
     def find(args, mode)
       return target_files_in_dir if args.empty?
@@ -44,12 +30,11 @@ module RuboCop
       files.map { |f| File.expand_path(f) }.uniq
     end
 
-    # Finds all Ruby source files under the current or other supplied
-    # directory. A Ruby source file is defined as a file with the `.rb`
-    # extension or a file with no extension that has a ruby shebang line
-    # as its first line.
-    # It is possible to specify includes and excludes using the config file,
-    # so you can include other Ruby files like Rakefiles and gemspecs.
+    # Finds all Ruby source files under the current or other supplied directory. A Ruby source file
+    # is defined as a file with the `.rb` extension or a file with no extension that has a ruby
+    # shebang line as its first line.
+    # It is possible to specify includes and excludes using the config file, so you can include
+    # other Ruby files like Rakefiles and gemspecs.
     # @param base_dir Root directory under which to search for
     #   ruby source files
     # @return [Array] Array of filenames
@@ -66,20 +51,10 @@ module RuboCop
       target_files.sort_by!(&order)
     end
 
-    def to_inspect?(file, hidden_files, base_dir_config)
-      return false if base_dir_config.file_to_exclude?(file)
-      return true if !hidden_files.bsearch do |hidden_file|
-        file <=> hidden_file
-      end && ruby_file?(file)
-
-      base_dir_config.file_to_include?(file)
-    end
-
-    # Search for files recursively starting at the given base directory using
-    # the given flags that determine how the match is made. Excluded files will
-    # be removed later by the caller, but as an optimization find_files removes
-    # the top level directories that are excluded in configuration in the
-    # normal way (dir/**/*).
+    # Search for files recursively starting at the given base directory using the given flags that
+    # determine how the match is made. Excluded files will be removed later by the caller, but as an
+    # optimization find_files removes the top level directories that are excluded in configuration
+    # in the normal way (dir/**/*).
     def find_files(base_dir, flags)
       # get all wanted directories first to improve speed of finding all files
       exclude_pattern = combined_exclude_glob_patterns(base_dir)
@@ -93,6 +68,17 @@ module RuboCop
       Dir.glob(patterns, flags).select { |path| FileTest.file?(path) }
     end
 
+    private
+
+    def to_inspect?(file, hidden_files, base_dir_config)
+      return false if base_dir_config.file_to_exclude?(file)
+      return true if !hidden_files.bsearch do |hidden_file|
+        file <=> hidden_file
+      end && ruby_file?(file)
+
+      base_dir_config.file_to_include?(file)
+    end
+
     def wanted_dir_patterns(base_dir, exclude_pattern, flags)
       # Escape glob characters in base_dir to avoid unwanted behavior.
       base_dir = base_dir.gsub(/[\\\{\}\[\]\*\?]/) do |reserved_glob_character|
@@ -124,21 +110,6 @@ module RuboCop
       "#{base_dir}/{#{patterns.join(',')}}"
     end
 
-    def ruby_extension?(file)
-      ruby_extensions.include?(File.extname(file))
-    end
-
-    def ruby_extensions
-      @ruby_extensions ||= begin
-        ext_patterns = all_cops_include.select { |pattern| pattern.start_with?('**/*.') }
-        ext_patterns.map { |pattern| pattern.sub('**/*', '') }
-      end
-    end
-
-    def ruby_filename?(file)
-      ruby_filenames.include?(File.basename(file))
-    end
-
     def ruby_filenames
       @ruby_filenames ||= begin
         file_patterns = all_cops_include.reject { |pattern| pattern.start_with?('**/*.') }
@@ -150,53 +121,72 @@ module RuboCop
       @all_cops_include ||= @config_store.for_pwd.for_all_cops['Include'].map(&:to_s)
     end
 
-    def ruby_executable?(file)
-      return false unless File.extname(file).empty? && File.exist?(file)
+    def process_explicit_path(path, mode)
+      files = path.include?('*') ? Dir[path] : [path]
 
-      first_line = File.open(file, &:readline)
-      /#!.*(#{ruby_interpreters(file).join('|')})/.match?(first_line)
-    rescue EOFError, ArgumentError => e
-      warn("Unprocessable file #{file}: #{e.class}, #{e.message}") if debug?
+      if mode == :only_recognized_file_types || force_exclusion?
+        files.select! { |file| included_file?(file) }
+      end
 
-      false
+      force_exclusion? ? without_excluded(files) : files
     end
 
-    def ruby_interpreters(file)
-      @config_store.for(file).for_all_cops['RubyInterpreters']
+    def without_excluded(files)
+      files.reject do |file|
+        # When --ignore-parent-exclusion is given, we must look at the configuration associated with
+        # the file, but in the default case when --ignore-parent-exclusion is not given, can safely
+        # look only at the configuration for the current directory, since it's only the Exclude
+        # parameters we're going to check.
+        config = @config_store.for(ignore_parent_exclusion? ? file : '.')
+        config.file_to_exclude?(file)
+      end
     end
 
-    def stdin?
-      @options.key?(:stdin)
+    def included_file?(file)
+      ruby_file?(file) || configured_include?(file)
     end
 
     def ruby_file?(file)
       stdin? || ruby_extension?(file) || ruby_filename?(file) || ruby_executable?(file)
     end
 
-    def configured_include?(file)
-      @config_store.for_pwd.file_to_include?(file)
+    def stdin?
+      @options.key?(:stdin)
     end
 
-    def included_file?(file)
-      ruby_file?(file) || configured_include?(file)
+    def ruby_extension?(file)
+      ruby_extensions.include?(File.extname(file))
     end
 
-    def process_explicit_path(path, mode)
-      files = path.include?('*') ? Dir[path] : [path]
-
-      if mode == :only_recognized_file_types || force_exclusion?
-        files.select! { |file| included_file?(file) }
+    def ruby_extensions
+      @ruby_extensions ||= begin
+        ext_patterns = all_cops_include.select { |pattern| pattern.start_with?('**/*.') }
+        ext_patterns.map { |pattern| pattern.sub('**/*', '') }
       end
+    end
 
-      return files unless force_exclusion?
+    def ruby_filename?(file)
+      ruby_filenames.include?(File.basename(file))
+    end
 
-      files.reject do |file|
-        config = @config_store.for(file)
-        config.file_to_exclude?(file)
-      end
+    def configured_include?(file)
+      @config_store.for_pwd.file_to_include?(file)
     end
 
-    private
+    def ruby_executable?(file)
+      return false unless File.extname(file).empty? && File.exist?(file)
+
+      first_line = File.open(file, &:readline)
+      /#!.*(#{ruby_interpreters(file).join('|')})/.match?(first_line)
+    rescue EOFError, ArgumentError => e
+      warn("Unprocessable file #{file}: #{e.class}, #{e.message}") if debug?
+
+      false
+    end
+
+    def ruby_interpreters(file)
+      @config_store.for(file).for_all_cops['RubyInterpreters']
+    end
 
     def order
       if fail_fast?
@@ -206,5 +196,21 @@ module RuboCop
         :itself
       end
     end
+
+    def force_exclusion?
+      @options[:force_exclusion]
+    end
+
+    def ignore_parent_exclusion?
+      @options[:ignore_parent_exclusion]
+    end
+
+    def debug?
+      @options[:debug]
+    end
+
+    def fail_fast?
+      @options[:fail_fast]
+    end
   end
 end

data/lib/rubocop/target_ruby.rb

@@ -4,7 +4,7 @@ module RuboCop
   # The kind of Ruby that code inspected by RuboCop is written in.
   # @api private
   class TargetRuby
-    KNOWN_RUBIES = [2.0, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 3.0, 3.1, 3.2, 3.3].freeze
+    KNOWN_RUBIES = [2.0, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 3.0, 3.1, 3.2, 3.3, 3.4].freeze
     DEFAULT_VERSION = 2.7
 
     OBSOLETE_RUBIES = {
@@ -96,18 +96,20 @@ module RuboCop
       end
 
       def version_from_gemspec_file(file)
-        processed_source = ProcessedSource.from_file(file, DEFAULT_VERSION)
+        processed_source = ProcessedSource.from_file(
+          file, DEFAULT_VERSION, parser_engine: @config.parser_engine
+        )
         required_ruby_version(processed_source.ast).first
       end
 
       def version_from_right_hand_side(right_hand_side)
         gem_requirement_versions = gem_requirement_versions(right_hand_side)
 
-        if right_hand_side.array_type?
+        if right_hand_side.array_type? && right_hand_side.children.all?(&:str_type?)
           version_from_array(right_hand_side)
         elsif gem_requirement_versions
           gem_requirement_versions.map(&:value)
-        else
+        elsif right_hand_side.str_type?
           right_hand_side.value
         end
       end

data/lib/rubocop/version.rb

@@ -3,9 +3,9 @@
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '1.61.0'
+    STRING = '1.62.1'
 
-    MSG = '%<version>s (using Parser %<parser_version>s, ' \
+    MSG = '%<version>s (using %<parser_version>s, ' \
           'rubocop-ast %<rubocop_ast_version>s, ' \
           'running on %<ruby_engine>s %<ruby_version>s)%<server_mode>s [%<ruby_platform>s]'
 
@@ -20,7 +20,7 @@ module RuboCop
     # @api private
     def self.version(debug: false, env: nil)
       if debug
-        verbose_version = format(MSG, version: STRING, parser_version: Parser::VERSION,
+        verbose_version = format(MSG, version: STRING, parser_version: parser_version,
                                       rubocop_ast_version: RuboCop::AST::Version::STRING,
                                       ruby_engine: RUBY_ENGINE, ruby_version: RUBY_VERSION,
                                       server_mode: server_mode,
@@ -39,6 +39,21 @@ module RuboCop
       end
     end
 
+    # @api private
+    def self.parser_version
+      config_path = ConfigFinder.find_config_path(Dir.pwd)
+      yaml = YAML.safe_load(
+        File.read(config_path), permitted_classes: [Regexp, Symbol], aliases: true
+      )
+
+      if yaml.dig('AllCops', 'ParserEngine') == 'parser_prism'
+        require 'prism'
+        "Prism #{Prism::VERSION}"
+      else
+        "Parser #{Parser::VERSION}"
+      end
+    end
+
     # @api private
     def self.extension_versions(env)
       features = Util.silence_warnings do

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: rubocop
 version: !ruby/object:Gem::Version
-  version: 1.61.0
+  version: 1.62.1
 platform: ruby
 authors:
 - Bozhidar Batsov
 - Jonas Arvidsson
 - Yuji Nakayama
-autorequire:
+autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-02-29 00:00:00.000000000 Z
+date: 2024-03-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -134,7 +134,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.30.0
+        version: 1.31.1
     - - "<"
       - !ruby/object:Gem::Version
         version: '2.0'
@@ -144,7 +144,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.30.0
+        version: 1.31.1
     - - "<"
       - !ruby/object:Gem::Version
         version: '2.0'
@@ -1031,12 +1031,12 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://rubocop.org/
-  changelog_uri: https://github.com/rubocop/rubocop/releases/tag/v1.61.0
+  changelog_uri: https://github.com/rubocop/rubocop/releases/tag/v1.62.1
   source_code_uri: https://github.com/rubocop/rubocop/
-  documentation_uri: https://docs.rubocop.org/rubocop/1.61/
+  documentation_uri: https://docs.rubocop.org/rubocop/1.62/
   bug_tracker_uri: https://github.com/rubocop/rubocop/issues
   rubygems_mfa_required: 'true'
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -1051,8 +1051,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
-signing_key:
+rubygems_version: 3.4.22
+signing_key: 
 specification_version: 4
 summary: Automatic Ruby code style checking tool.
 test_files: []