rubocop 1.86.0 → 1.86.2

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

@@ -13,6 +13,12 @@ module RuboCop
       # array, while `method_defined?` will do direct method lookup, which is much
       # faster and consumes less memory.
       #
+      # NOTE: `constants.include?` is not handled by this cop because
+      # `Module#const_defined?` has different lookup behavior than
+      # `Module#constants` - `const_defined?` searches up to `Object`
+      # (top-level constants like `String`, `Integer`, etc.) while
+      # `constants` does not, which can cause behavior changes after autocorrection.
+      #
       # @example
       #   # bad
       #   Array.instance_methods.include?(:size)
@@ -28,27 +34,17 @@ module RuboCop
       #
       #   # bad
       #   Array.class_variables.include?(:foo)
-      #   Array.constants.include?(:foo)
       #   Array.private_instance_methods.include?(:foo)
       #   Array.protected_instance_methods.include?(:foo)
       #   Array.public_instance_methods.include?(:foo)
-      #   Array.included_modules.include?(:foo)
       #
       #   # good
       #   Array.class_variable_defined?(:foo)
-      #   Array.const_defined?(:foo)
       #   Array.private_method_defined?(:foo)
       #   Array.protected_method_defined?(:foo)
       #   Array.public_method_defined?(:foo)
-      #   Array.include?(:foo)
-      #
-      # @example AllowedMethods: [included_modules]
-      #
-      #   # good
-      #   Array.included_modules.include?(:foo)
       #
       class ModuleMemberExistenceCheck < Base
-        include AllowedMethods
         extend AutoCorrector
 
         MSG = 'Use `%<replacement>s` instead.'
@@ -63,15 +59,13 @@ module RuboCop
 
         METHOD_REPLACEMENTS = {
           class_variables: :class_variable_defined?,
-          constants: :const_defined?,
-          included_modules: :include?,
           instance_methods: :method_defined?,
           private_instance_methods: :private_method_defined?,
           protected_instance_methods: :protected_method_defined?,
           public_instance_methods: :public_method_defined?
         }.freeze
 
-        METHODS_WITHOUT_INHERIT_PARAM = Set[:class_variables, :included_modules].freeze
+        METHODS_WITHOUT_INHERIT_PARAM = Set[:class_variables].freeze
         METHODS_WITH_INHERIT_PARAM =
           (METHOD_REPLACEMENTS.keys.to_set - METHODS_WITHOUT_INHERIT_PARAM).freeze
 
@@ -81,7 +75,6 @@ module RuboCop
           return unless (parent = node.parent)
           return unless module_member_inclusion?(parent)
           return unless simple_method_argument?(node) && simple_method_argument?(parent)
-          return if allowed_method?(node.method_name)
 
           offense_range = node.location.selector.join(parent.source_range.end)
           replacement = replacement_for(node, parent)

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

@@ -13,30 +13,50 @@ module RuboCop
       # classes that logically belong with the main class.
       #
       # @example
-      #   # bad
+      #   # bad - Multiple top-level classes
       #   class Foo
       #   end
       #
       #   class Bar
       #   end
       #
-      #   # bad
+      #   # bad - Multiple top-level modules
+      #   module Foo
+      #   end
+      #
+      #   module Bar
+      #   end
+      #
+      #   # bad - A top-level class and a top-level module
       #   class Foo
       #   end
       #
       #   module Bar
       #   end
       #
-      #   # good
+      #   # good - A single top-level class
       #   class Foo
       #   end
       #
-      #   # good
+      #   # good - A single top-level module
+      #   module Foo
+      #   end
+      #
+      #   # good - Nested classes within a single top-level class
       #   class Foo
       #     class Bar
       #     end
       #   end
       #
+      #   # good - Multiple classes within a single top-level module
+      #   module Foo
+      #     class Bar
+      #     end
+      #
+      #     class Baz
+      #     end
+      #   end
+      #
       # @example AllowedClasses: ['AllowedClass']
       #   # good
       #   class Foo

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

@@ -99,6 +99,7 @@ module RuboCop
                        end
           return unless key
           return if accumulator_used_in_expressions?(block_node, key, value)
+          return if nested_match?(key) || nested_match?(value)
 
           register_offense(node, block_node, key, value)
         end
@@ -108,6 +109,21 @@ module RuboCop
           references_variable?(key, acc_name) || references_variable?(value, acc_name)
         end
 
+        def nested_match?(node)
+          node.each_node(:call).any? do |send_node|
+            next false unless RESTRICT_ON_SEND.include?(send_node.method_name)
+
+            inner_block = send_node.block_node
+            next false unless inner_block
+
+            if send_node.method?(:each_with_object)
+              each_with_object_to_hash?(inner_block)
+            else
+              inject_to_hash?(inner_block)
+            end
+          end
+        end
+
         def accumulator_name(block_node)
           index = block_node.method?(:each_with_object) ? 1 : 0
           block_node.argument_list[index].name

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

@@ -82,6 +82,7 @@ module RuboCop
           tIDENTIFIER kBREAK kNEXT kRETURN kSUPER kYIELD
         ].freeze
         ARITHMETIC_OPERATOR_TOKENS = %i[tDIVIDE tDSTAR tMINUS tPERCENT tPLUS tSTAR2].freeze
+        STRING_LITERAL_BEGIN_TOKENS = %i[tSTRING_BEG tXSTRING_BEG tREGEXP_BEG tSYMBEG].freeze
 
         def on_new_investigation
           return unless processed_source.ast
@@ -105,6 +106,7 @@ module RuboCop
             string_concatenation?(range.source_line) ||
             start_with_arithmetic_operator?(range) ||
             inside_string_literal_or_method_with_argument?(range) ||
+            inside_string_literal_with_interpolation?(range) ||
             leading_dot_method_chain_with_blank_line?(range)
         end
 
@@ -132,6 +134,20 @@ module RuboCop
           end
         end
 
+        def inside_string_literal_with_interpolation?(range)
+          string_depth = 0
+          processed_source.tokens.each do |token|
+            break if token.pos.begin_pos >= range.begin_pos
+
+            if STRING_LITERAL_BEGIN_TOKENS.include?(token.type)
+              string_depth += 1
+            elsif token.type == :tSTRING_END
+              string_depth -= 1
+            end
+          end
+          string_depth.positive?
+        end
+
         def leading_dot_method_chain_with_blank_line?(range)
           return false unless range.source_line.strip.start_with?('.', '&.')
 

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

@@ -270,14 +270,17 @@ module RuboCop
           end
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def body_range?(begin_node, node)
+          return false if begin_node.chained?
           return false unless node.range_type?
           return false unless (parent = begin_node.parent)
-          return false if parent.pair_type?
+          return false unless parent.begin_type?
 
           (node.begin.nil? && begin_node == parent.children.first) ||
             (node.end.nil? && begin_node == parent.children.last)
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def disallowed_one_line_pattern_matching?(begin_node, node)
           if (parent = begin_node.parent)

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

@@ -59,7 +59,7 @@ module RuboCop
 
         def initialize(config = nil, options = nil)
           super
-          @allowed_send_nodes = []
+          @allowed_send_nodes = Set.new.compare_by_identity
           @local_variables_scopes = Hash.new { |hash, key| hash[key] = [] }.compare_by_identity
         end
 
@@ -187,7 +187,7 @@ module RuboCop
         def allow_self(node)
           return unless node.send_type? && node.self_receiver?
 
-          @allowed_send_nodes << node
+          @allowed_send_nodes.add(node)
         end
 
         def add_lhs_to_local_variables_scopes(rhs, lhs)

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

@@ -9,6 +9,16 @@ module RuboCop
       # Therefore, this cop detects and autocorrects redundant `keyword_init: nil`
       # and `keyword_init: true` in `Struct.new`.
       #
+      # This cop is disabled by default because `keyword_init: true` is not purely
+      # redundant. It changes behavior in the following ways:
+      #
+      # - `Struct#keyword_init?` returns `true` instead of `nil`.
+      # - A `Struct` with `keyword_init: true` accepts a `Hash` argument and
+      #   expands it as keyword arguments, whereas without it the `Hash` is
+      #   treated as a positional argument.
+      # - `keyword_init: true` raises an `ArgumentError` for positional arguments,
+      #   enforcing keyword-only initialization.
+      #
       # @safety
       #   This autocorrect is unsafe because when the value of `keyword_init` changes
       #   from `true` to `nil`, the return value of `Struct#keyword_init?` changes.

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

@@ -98,7 +98,16 @@ module RuboCop
         MSG_USE_SLASHES = 'Use `//` around regular expression.'
         MSG_USE_PERCENT_R = 'Use `%r` around regular expression.'
 
+        PAIR_DELIMITER_PATTERNS = {
+          ['(', ')'] => /\\.|[()]/,
+          ['[', ']'] => /\\.|[\[\]]/,
+          ['{', '}'] => /\\.|[{}]/,
+          ['<', '>'] => /\\.|[<>]/
+        }.freeze
+
         def on_regexp(node)
+          return if slash_literal?(node) && percent_r_delimiters_conflict?(node)
+
           message = if slash_literal?(node)
                       MSG_USE_PERCENT_R unless allowed_slash_literal?(node)
                     else
@@ -115,6 +124,26 @@ module RuboCop
 
         private
 
+        def percent_r_delimiters_conflict?(node)
+          opening, closing = preferred_delimiters
+          return false unless (pattern = PAIR_DELIMITER_PATTERNS[[opening, closing]])
+
+          !balanced_delimiters?(node_body(node), opening, closing, pattern)
+        end
+
+        def balanced_delimiters?(text, opening, closing, pattern)
+          depth = 0
+          text.scan(pattern) do |match|
+            if match == opening
+              depth += 1
+            elsif match == closing
+              depth -= 1
+              return false if depth.negative?
+            end
+          end
+          depth.zero?
+        end
+
         def allowed_slash_literal?(node)
           (style == :slashes && !contains_disallowed_slash?(node)) || allowed_mixed_slash?(node)
         end

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

@@ -65,7 +65,10 @@ module RuboCop
 
           message = format(MSG, conditional_type: node.keyword)
           add_offense(if_branch.loc.keyword, message: message) do |corrector|
+            next if ignored_node?(node)
+
             autocorrect(corrector, node, if_branch)
+            ignore_node(if_branch)
           end
         end
 
@@ -115,9 +118,8 @@ module RuboCop
         end
 
         def correct_node(corrector, node)
-          corrector.replace(node.loc.keyword, 'if') if node.unless? && !part_of_ignored_node?(node)
+          corrector.replace(node.loc.keyword, 'if') if node.unless?
           corrector.replace(node.condition, chainable_condition(node))
-          ignore_node(node)
         end
 
         def correct_for_guard_condition_style(corrector, node, if_branch)

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

@@ -260,10 +260,10 @@ module RuboCop
         end
 
         def begin_pos_for_replacement(node)
-          expr = node.send_node.source_range
+          send_node = node.send_node
 
-          if (paren_pos = (expr.source =~ /\(\s*\)$/))
-            expr.begin_pos + paren_pos
+          if send_node.parenthesized? && send_node.arguments.empty?
+            send_node.loc.begin.begin_pos
           else
             node.loc.begin.begin_pos
           end

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

@@ -16,6 +16,11 @@ module RuboCop
       #   # good
       #   x += 1 while x < 10
       #
+      #   # good
+      #   while x < 10
+      #     y += 1 if x.odd?
+      #   end
+      #
       #   # bad
       #   until x > 10
       #     x += 1
@@ -24,6 +29,11 @@ module RuboCop
       #   # good
       #   x += 1 until x > 10
       #
+      #   # good
+      #   until x > 10
+      #     y += 1 unless x.even?
+      #   end
+      #
       #   # bad
       #   x += 100 while x < 500 # a long comment that makes code too long if it were a single line
       #
@@ -45,6 +55,12 @@ module RuboCop
           end
         end
         alias on_until on_while
+
+        private
+
+        def non_eligible_body?(body)
+          body&.conditional? || super
+        end
       end
     end
   end

data/lib/rubocop/cop/team.rb

@@ -11,6 +11,9 @@ module RuboCop
     # (unless autocorrections happened).
     # rubocop:disable Metrics/ClassLength
     class Team
+      InvestigationResult = Struct.new(:report, :corrector)
+      private_constant :InvestigationResult
+
       # @return [Team]
       def self.new(cop_or_classes, config, options = {})
         # Support v0 api:
@@ -89,31 +92,25 @@ module RuboCop
 
       # @return [Commissioner::InvestigationReport]
       def investigate(processed_source, offset: 0, original: processed_source)
-        be_ready
-
-        # The autocorrection process may have to be repeated multiple times
-        # until there are no corrections left to perform
-        # To speed things up, run autocorrecting cops by themselves, and only
-        # run the other cops when no corrections are left
-        on_duty = roundup_relevant_cops(processed_source)
+        result = investigate_with_corrector(processed_source, offset: offset, original: original)
+        autocorrect(processed_source, result.corrector)
+        result.report
+      end
 
-        autocorrect_cops, other_cops = on_duty.partition(&:autocorrect?)
-        report = investigate_partial(autocorrect_cops, processed_source,
-                                     offset: offset, original: original)
+      # @return [Array<Offense>]
+      def investigate_fragments(fragments, original:)
+        @updated_source_file = false
 
-        unless autocorrect(processed_source, report, offset: offset, original: original)
-          # If we corrected some errors, another round of inspection will be
-          # done, and any other offenses will be caught then, so only need
-          # to check other_cops if no correction was done
-          report = report.merge(investigate_partial(other_cops, processed_source,
-                                                    offset: offset, original: original))
-        end
+        offenses, errors, warnings, corrector =
+          fragments.each_with_object([[], [], [], nil]) do |fragment, data|
+            investigate_fragment(fragment, original, data)
+          end
 
-        process_errors(processed_source.path, report.errors)
+        autocorrect(original, corrector)
+        @errors = errors
+        @warnings = warnings
 
-        report
-      ensure
-        @ready = false
+        offenses
       end
 
       # @deprecated
@@ -136,14 +133,13 @@ module RuboCop
 
       private
 
-      def autocorrect(processed_source, report, original:, offset:)
+      def autocorrect(processed_source, corrector)
         @updated_source_file = false
         return unless autocorrect?
-        return if report.processed_source.parser_error
+        return unless corrector
+        return if corrector.empty?
 
-        new_source = autocorrect_report(report, original: original, offset: offset)
-
-        return unless new_source
+        new_source = corrector.rewrite
 
         if @options[:stdin]
           # holds source read in from stdin, when --stdin option is used
@@ -174,6 +170,54 @@ module RuboCop
         commissioner.investigate(processed_source, offset: offset, original: original)
       end
 
+      def investigate_with_corrector(processed_source, offset:, original:)
+        be_ready
+
+        # The autocorrection process may have to be repeated multiple times
+        # until there are no corrections left to perform
+        # To speed things up, run autocorrecting cops by themselves, and only
+        # run the other cops when no corrections are left
+        on_duty = roundup_relevant_cops(processed_source)
+
+        autocorrect_cops, other_cops = on_duty.partition(&:autocorrect?)
+        report = investigate_partial(autocorrect_cops, processed_source,
+                                     offset: offset, original: original)
+
+        corrector = collated_corrector(report, offset: offset, original: original)
+
+        unless corrector
+          # If we corrected some errors, another round of inspection will be
+          # done, and any other offenses will be caught then, so only need
+          # to check other_cops if no correction was done
+          report = report.merge(investigate_partial(other_cops, processed_source,
+                                                    offset: offset, original: original))
+        end
+
+        process_errors(processed_source.path, report.errors)
+
+        InvestigationResult.new(report, corrector)
+      ensure
+        @ready = false
+      end
+
+      def investigate_fragment(fragment, original, data)
+        offenses, errors, warnings, corrector = data
+        result = investigate_with_corrector(
+          fragment[:processed_source],
+          offset: fragment[:offset],
+          original: original
+        )
+
+        offenses.concat(result.report.offenses)
+        if result.corrector
+          corrector ||= Corrector.new(original)
+          merge_corrector!(corrector, result.corrector, offset: 0)
+          data[3] = corrector
+        end
+        errors.concat(@errors)
+        warnings.concat(@warnings)
+      end
+
       # @return [Array<cop>]
       def roundup_relevant_cops(processed_source)
         cops.select do |cop|
@@ -200,28 +244,35 @@ module RuboCop
         cop.class.support_target_rails_version?(cop.target_rails_version)
       end
 
-      def autocorrect_report(report, offset:, original:)
+      def collated_corrector(report, offset:, original:)
+        return unless autocorrect?
+        return if report.processed_source.parser_error
+
         corrector = collate_corrections(report, offset: offset, original: original)
 
-        corrector.rewrite unless corrector.empty?
+        corrector unless corrector.empty?
       end
 
       def collate_corrections(report, offset:, original:)
         corrector = Corrector.new(original)
 
         each_corrector(report) do |to_merge|
-          suppress_clobbering do
-            if corrector.source_buffer == to_merge.source_buffer
-              corrector.merge!(to_merge)
-            else
-              corrector.import!(to_merge, offset: offset)
-            end
-          end
+          merge_corrector!(corrector, to_merge, offset: offset)
         end
 
         corrector
       end
 
+      def merge_corrector!(corrector, to_merge, offset:)
+        suppress_clobbering do
+          if corrector.source_buffer == to_merge.source_buffer
+            corrector.merge!(to_merge)
+          else
+            corrector.import!(to_merge, offset: offset)
+          end
+        end
+      end
+
       def each_corrector(report)
         skips = Set.new
         report.cop_reports.each do |cop_report|

data/lib/rubocop/formatter/disabled_config_formatter.rb

@@ -131,6 +131,9 @@ module RuboCop
       end
 
       def set_max(cfg, cop_name)
+        exclude_limits = RuboCop::ExcludeLimit.read_limits(cop_name)
+        cfg[:exclude_limit] = exclude_limits unless exclude_limits.empty?
+
         return unless cfg[:exclude_limit]
 
         cfg.merge!(cfg[:exclude_limit]) if should_set_max?(cop_name)
@@ -192,7 +195,7 @@ module RuboCop
           next unless value.is_a?(Array)
           next if value.empty?
 
-          value.map! { |v| v.nil? ? '~' : v } # Change nil back to ~ as in the YAML file.
+          value = value.map { |v| v.nil? ? '~' : v } # Change nil back to ~ as in the YAML file.
           output_buffer.puts "# #{param}: #{value.uniq.join(', ')}"
         end
       end

data/lib/rubocop/lsp/runtime.rb

@@ -23,7 +23,6 @@ module RuboCop
         RuboCop::LSP.enable
 
         @runner = RuboCop::Lsp::StdinRunner.new(config_store)
-        @cop_registry = RuboCop::Cop::Registry.global.to_h
 
         @safe_autocorrect = true
         @lint_mode = false
@@ -63,7 +62,7 @@ module RuboCop
           document_encoding,
           offense,
           path,
-          @cop_registry[offense.cop_name]&.first,
+          RuboCop::Cop::Registry.global.find_by_cop_name(offense.cop_name),
           processed_source
         ).to_lsp_diagnostic(config)
       end

data/lib/rubocop/mcp/server.rb

@@ -190,6 +190,8 @@ module RuboCop
           result = yield(path, source_code, safety)
 
           ::MCP::Tool::Response.new([{ type: 'text', text: result }])
+        rescue RuboCop::Error => e
+          ::MCP::Tool::Response.new([{ type: 'text', text: e.message }], error: true)
         end
       end
       # rubocop:enable Metrics/MethodLength, Metrics/ParameterLists

data/lib/rubocop/options.rb

@@ -16,7 +16,9 @@ module RuboCop
                       'root of the project. RuboCop will use this path to determine which ' \
                       'cops are enabled (via eg. Include/Exclude), and so that certain cops ' \
                       'like Naming/FileName can be checked.'
-    EXITING_OPTIONS = %i[version verbose_version show_cops show_docs_url lsp mcp].freeze
+    EXITING_OPTIONS = %i[
+      version verbose_version show_cops list_enabled_cops_for show_docs_url lsp mcp
+    ].freeze
     DEFAULT_MAXIMUM_EXCLUSION_ITEMS = 15
 
     def initialize
@@ -236,6 +238,7 @@ module RuboCop
     def add_additional_modes(opts)
       section(opts, 'Additional Modes') do
         option(opts, '-L', '--list-target-files')
+        option(opts, '--list-enabled-cops-for PATH')
         option(opts, '--show-cops [COP1,COP2,...]') do |list|
           @options[:show_cops] = list.nil? ? [] : list.split(',')
         end
@@ -474,8 +477,7 @@ module RuboCop
     end
 
     def invalid_arguments_for_parallel
-      [('--auto-gen-config' if @options.key?(:auto_gen_config)),
-       ('-F/--fail-fast'    if @options.key?(:fail_fast)),
+      [('-F/--fail-fast'    if @options.key?(:fail_fast)),
        ('--profile'         if @options[:profile]),
        ('--memory'          if @options[:memory]),
        ('--cache false'     if @options > { cache: 'false' })].compact
@@ -599,7 +601,7 @@ module RuboCop
       display_only_correctable:         ['Only output correctable offense messages.'],
       display_only_safe_correctable:    ['Only output safe-correctable offense messages',
                                          'when combined with --display-only-correctable.'],
-      show_cops:                        ['Shows the given cops, or all cops by',
+      show_cops:                        ['Show the given cops, or all cops by',
                                          'default, and their configurations for the',
                                          'current directory.',
                                          'You can use `*` as a wildcard.'],
@@ -628,6 +630,8 @@ module RuboCop
                                          'autocorrected source. This is especially useful',
                                          'when combined with --autocorrect and --stdin.'],
       list_target_files:                'List all files RuboCop will inspect.',
+      list_enabled_cops_for:            ['List which cops will inspect a given file or',
+                                         'directory.'],
       autocorrect:                      'Autocorrect offenses (only when it\'s safe).',
       auto_correct:                     '(same, deprecated)',
       safe_auto_correct:                '(same, deprecated)',

data/lib/rubocop/rspec/cop_helper.rb

@@ -6,6 +6,12 @@ require 'tempfile'
 module CopHelper
   extend RSpec::SharedContext
 
+  @integrated_plugins = false
+
+  class << self
+    attr_accessor :integrated_plugins
+  end
+
   let(:ruby_version) do
     # The minimum version Prism can parse is 3.3.
     ENV['PARSER_ENGINE'] == 'parser_prism' ? 3.3 : RuboCop::TargetRuby::DEFAULT_VERSION
@@ -18,11 +24,13 @@ module CopHelper
 
   before(:all) do
     next if ENV['RUBOCOP_CORE_DEVELOPMENT']
+    next if CopHelper.integrated_plugins
 
     plugins = Gem.loaded_specs.filter_map do |feature_name, feature_specification|
       feature_name if feature_specification.metadata['default_lint_roller_plugin']
     end
     RuboCop::Plugin.integrate_plugins(RuboCop::Config.new, plugins)
+    CopHelper.integrated_plugins = true
   end
 
   def inspect_source(source, file = nil)