rubocop 1.71.1 → 1.88.2

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

@@ -93,6 +93,7 @@ module RuboCop
 
         def on_array(node)
           if bracketed_array_of?(:str, node)
+            return if node.values.any?(&:heredoc?)
             return if complex_content?(node.values)
             return if within_matrix_of_complex_content?(node)
 

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

@@ -147,7 +147,7 @@ module RuboCop
         end
 
         def constant_portion?(node)
-          node.literal? || node.const_type?
+          node.recursive_literal? || node.const_type?
         end
 
         def actual_code_range(node)

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

@@ -76,7 +76,7 @@ module RuboCop
         end
 
         def supported_operators
-          Array(cop_config['SupportedOperators'])
+          @supported_operators ||= Array(cop_config['SupportedOperators']).freeze
         end
 
         def offended_ancestor?(node)

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

@@ -9,8 +9,10 @@ module RuboCop
       # `receiver.length < 1` and `receiver.size == 0` that can be
       # replaced by `receiver.empty?` and `!receiver.empty?`.
       #
-      # NOTE: `File`, `Tempfile`, and `StringIO` do not have `empty?`
-      # so allow `size == 0` and `size.zero?`.
+      # NOTE: `File`, `Tempfile`, `StringIO`, and `File::Stat` do not have `empty?`
+      # so allow `size == 0` and `size.zero?`. Note that when a `File::Stat` object
+      # is stored in a variable (e.g. `stat = File.stat(path); stat.size.zero?`),
+      # the cop cannot detect the type and may still register a false positive.
       #
       # @safety
       #   This cop is unsafe because it cannot be guaranteed that the receiver
@@ -146,7 +148,8 @@ module RuboCop
         # @!method non_polymorphic_collection?(node)
         def_node_matcher :non_polymorphic_collection?, <<~PATTERN
           {(send (send (send (const {nil? cbase} :File) :stat _) ...) ...)
-           (send (send (send (const {nil? cbase} {:File :Tempfile :StringIO}) {:new :open} ...) ...) ...)}
+           (send (send (send (const {nil? cbase} {:File :Tempfile :StringIO}) {:new :open} ...) ...) ...)
+           (send (send (send (const (const {nil? cbase} :File) :Stat) :new ...) ...) ...)}
         PATTERN
       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:
@@ -56,6 +59,16 @@ module RuboCop
 
       attr_reader :errors, :warnings, :updated_source_file, :cops
 
+      # When set to true, the corrected source is not written back to the
+      # inspected file; it is exposed through `#updated_source` instead.
+      # @api private
+      attr_accessor :defer_corrections
+
+      # The corrected source of the last investigation, if corrections were
+      # made with `#defer_corrections` enabled.
+      # @api private
+      attr_reader :updated_source
+
       alias updated_source_file? updated_source_file
 
       def initialize(cops, config = nil, options = {})
@@ -89,31 +102,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,23 +143,26 @@ module RuboCop
 
       private
 
-      def autocorrect(processed_source, report, original:, offset:)
+      def autocorrect(processed_source, corrector)
         @updated_source_file = false
+        @updated_source = nil
         return unless autocorrect?
-        return if report.processed_source.parser_error
-
-        new_source = autocorrect_report(report, original: original, offset: offset)
+        return unless corrector
+        return if corrector.empty?
 
-        return unless new_source
+        apply_correction(processed_source, corrector.rewrite)
+        @updated_source_file = true
+      end
 
+      def apply_correction(processed_source, new_source)
         if @options[:stdin]
           # holds source read in from stdin, when --stdin option is used
           @options[:stdin] = new_source
+        elsif defer_corrections
+          @updated_source = new_source
         else
-          filename = processed_source.file_path
-          File.write(filename, new_source)
+          File.write(processed_source.file_path, new_source)
         end
-        @updated_source_file = true
       end
 
       def be_ready
@@ -174,11 +184,59 @@ 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|
-          next true if processed_source.comment_config.cop_opted_in?(cop)
           next false if cop.excluded_file?(processed_source.file_path)
+          next true if processed_source.comment_config.cop_opted_in?(cop)
           next false unless @registry.enabled?(cop, @config)
 
           support_target_ruby_version?(cop) && support_target_rails_version?(cop)
@@ -200,28 +258,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 offset.positive?
-              corrector.import!(to_merge, offset: offset)
-            else
-              corrector.merge!(to_merge)
-            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|
@@ -279,7 +344,7 @@ module RuboCop
         @errors << message
         warn message
         if debug?
-          puts error.message, error.backtrace
+          puts error.full_message
         else
           warn 'To see the complete backtrace run rubocop -d.'
         end

data/lib/rubocop/cop/util.rb

@@ -32,7 +32,7 @@ module RuboCop
       end
 
       def parentheses?(node)
-        node.loc.respond_to?(:end) && node.loc.end&.is?(')')
+        node.loc_is?(:end, ')')
       end
 
       # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
@@ -76,7 +76,7 @@ module RuboCop
         loc = node.loc
         selector = if node.type?(:super, :yield)
                      loc.keyword
-                   elsif node.type?(:def, :defs)
+                   elsif node.any_def_type?
                      loc.name
                    else
                      loc.selector
@@ -117,10 +117,9 @@ module RuboCop
       # with calls chained to the end of it.
       def first_part_of_call_chain(node)
         while node
-          case node.type
-          when :send
+          if node.call_type?
             node = node.receiver
-          when :block
+          elsif node.any_block_type?
             node = node.send_node
           else
             break

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

@@ -5,15 +5,19 @@ module RuboCop
     module Utils
       # Parses {Kernel#sprintf} format strings.
       class FormatString
-        DIGIT_DOLLAR  = /(\d+)\$/.freeze
+        # Escaping the `#` in `INTERPOLATION` and `TEMPLATE_NAME` is necessary to
+        # avoid a bug in Ruby 3.2.0
+        # See: https://bugs.ruby-lang.org/issues/19379
+        DIGIT_DOLLAR  = /(?<arg_number>\d+)\$/.freeze
+        INTERPOLATION = /\#\{.*?\}/.freeze
         FLAG          = /[ #0+-]|#{DIGIT_DOLLAR}/.freeze
         NUMBER_ARG    = /\*#{DIGIT_DOLLAR}?/.freeze
-        NUMBER        = /\d+|#{NUMBER_ARG}/.freeze
+        NUMBER        = /\d+|#{NUMBER_ARG}|#{INTERPOLATION}/.freeze
         WIDTH         = /(?<width>#{NUMBER})/.freeze
-        PRECISION     = /\.(?<precision>#{NUMBER})/.freeze
+        PRECISION     = /\.(?<precision>#{NUMBER}?)/.freeze
         TYPE          = /(?<type>[bBdiouxXeEfgGaAcps])/.freeze
         NAME          = /<(?<name>\w+)>/.freeze
-        TEMPLATE_NAME = /\{(?<name>\w+)\}/.freeze
+        TEMPLATE_NAME = /(?<!\#)\{(?<name>\w+)\}/.freeze
 
         SEQUENCE = /
             % (?<type>%)
@@ -41,7 +45,7 @@ module RuboCop
         #
         # @see https://ruby-doc.org/core-2.6.3/Kernel.html#method-i-format
         class FormatSequence
-          attr_reader :begin_pos, :end_pos, :flags, :width, :precision, :name, :type
+          attr_reader :begin_pos, :end_pos, :flags, :width, :precision, :name, :type, :arg_number
 
           def initialize(match)
             @source = match[0]
@@ -52,6 +56,7 @@ module RuboCop
             @precision = match[:precision]
             @name = match[:name]
             @type = match[:type]
+            @arg_number = match[:arg_number]
           end
 
           def percent?
@@ -66,6 +71,16 @@ module RuboCop
             name && @source.include?('{')
           end
 
+          def variable_width?
+            !!width&.start_with?('*')
+          end
+
+          def variable_width_argument_number
+            return unless variable_width?
+
+            width == '*' ? 1 : width.match(DIGIT_DOLLAR)['arg_number'].to_i
+          end
+
           # Number of arguments required for the format sequence
           def arity
             @source.scan('*').count + 1

data/lib/rubocop/cop/variable_force/assignment.rb

@@ -110,8 +110,13 @@ module RuboCop
         end
 
         def multiple_assignment_node
-          return nil unless node.parent&.mlhs_type?
-          return nil unless (grandparent_node = node.parent&.parent)
+          return nil unless (candidate_mlhs_node = node.parent)
+
+          # In `(foo, bar), *baz`, the splat node must be traversed as well.
+          candidate_mlhs_node = candidate_mlhs_node.parent if candidate_mlhs_node.splat_type?
+
+          return nil unless candidate_mlhs_node.mlhs_type?
+          return nil unless (grandparent_node = node.parent.parent)
           if (node = find_multiple_assignment_node(grandparent_node))
             return node
           end
@@ -139,7 +144,6 @@ module RuboCop
 
         def find_multiple_assignment_node(grandparent_node)
           return unless grandparent_node.type == MULTIPLE_LEFT_HAND_SIDE_TYPE
-          return if grandparent_node.children.any?(&:splat_type?)
 
           parent = grandparent_node.parent
           return parent if parent.type == MULTIPLE_ASSIGNMENT_TYPE

data/lib/rubocop/cop/variable_force/branch.rb

@@ -254,8 +254,8 @@ module RuboCop
           end
         end
 
-        # Mix-in module for logical operator control structures.
-        module LogicalOperator
+        # Mix-in module for operator control structures.
+        module Operator
           def always_run?
             left_body?
           end
@@ -263,7 +263,15 @@ module RuboCop
 
         # left_body && right_body
         class And < Base
-          include LogicalOperator
+          include Operator
+
+          define_predicate :left_body?,  child_index: 0
+          define_predicate :right_body?, child_index: 1
+        end
+
+        # left_body &&= right_body
+        class AndAsgn < Base
+          include Operator
 
           define_predicate :left_body?,  child_index: 0
           define_predicate :right_body?, child_index: 1
@@ -271,7 +279,23 @@ module RuboCop
 
         # left_body || right_body
         class Or < Base
-          include LogicalOperator
+          include Operator
+
+          define_predicate :left_body?,  child_index: 0
+          define_predicate :right_body?, child_index: 1
+        end
+
+        # left_body ||= right_body
+        class OrAsgn < Base
+          include Operator
+
+          define_predicate :left_body?,  child_index: 0
+          define_predicate :right_body?, child_index: 1
+        end
+
+        # e.g. left_body += right_body
+        class OpAsgn < Base
+          include Operator
 
           define_predicate :left_body?,  child_index: 0
           define_predicate :right_body?, child_index: 1
@@ -322,8 +346,8 @@ module RuboCop
           end
         end
 
-        CLASSES_BY_TYPE = Base.classes.each_with_object({}) do |klass, classes|
-          classes[klass.type] = klass
+        CLASSES_BY_TYPE = Base.classes.to_h do |klass|
+          [klass.type, klass]
         end
       end
     end

data/lib/rubocop/cop/variable_force/scope.rb

@@ -46,7 +46,7 @@ module RuboCop
           else
             child_index = case node.type
                           when :module, :sclass then 1
-                          when :def, :class, :block, :numblock then 2
+                          when :def, :class, :block, :numblock, :itblock then 2
                           when :defs then 3
                           end
 

data/lib/rubocop/cop/variable_force/variable.rb

@@ -31,11 +31,18 @@ module RuboCop
         def assign(node)
           assignment = Assignment.new(node, self)
 
-          @assignments.last&.reassigned! unless captured_by_block?
+          mark_last_as_reassigned!(assignment)
 
           @assignments << assignment
         end
 
+        def mark_last_as_reassigned!(assignment)
+          return if captured_by_block?
+          return unless assignment.branch == @assignments.last&.branch
+
+          @assignments.last&.reassigned!
+        end
+
         def referenced?
           !@references.empty?
         end
@@ -72,7 +79,7 @@ module RuboCop
           parent = parent.parent if parent&.begin_type?
           return false if parent.nil?
 
-          parent.type?(:if, :while, :until) && parent.modifier_form?
+          parent.basic_conditional? && parent.modifier_form?
         end
 
         def capture_with_block!
@@ -100,7 +107,7 @@ module RuboCop
         end
 
         def method_argument?
-          argument? && %i[def defs].include?(@scope.node.type)
+          argument? && @scope.node.any_def_type?
         end
 
         def block_argument?

data/lib/rubocop/cop/variable_force.rb

@@ -54,7 +54,7 @@ module RuboCop
 
       ZERO_ARITY_SUPER_TYPE = :zsuper
 
-      TWISTED_SCOPE_TYPES = %i[block numblock class sclass defs module].freeze
+      TWISTED_SCOPE_TYPES = %i[block numblock itblock class sclass defs module].freeze
       SCOPE_TYPES = (TWISTED_SCOPE_TYPES + [:def]).freeze
 
       SEND_TYPE = :send
@@ -71,6 +71,8 @@ module RuboCop
         end
       end
 
+      BRANCH_NODES = %i[if case case_match rescue].freeze
+
       def variable_table
         @variable_table ||= VariableTable.new(self)
       end
@@ -236,11 +238,16 @@ module RuboCop
       end
 
       def process_loop(node)
-        if POST_CONDITION_LOOP_TYPES.include?(node.type)
+        if node.post_condition_loop?
           # See the comment at the end of file for this behavior.
           condition_node, body_node = *node
           process_node(body_node)
           process_node(condition_node)
+        elsif node.for_type?
+          # In `for item in items` the rightmost expression is evaluated first.
+          process_node(node.collection)
+          process_node(node.variable)
+          process_node(node.body) if node.body
         else
           process_children(node)
         end
@@ -296,7 +303,7 @@ module RuboCop
         variable_table.accessible_variables.each { |variable| variable.reference!(node) }
       end
 
-      # Mark all assignments which are referenced in the same loop
+      # Mark last assignments which are referenced in the same loop
       # as referenced by ignoring AST order since they would be referenced
       # in next iteration.
       def mark_assignments_as_referenced_in_loop(node)
@@ -308,13 +315,12 @@ module RuboCop
           # would be skipped here.
           next unless variable
 
-          variable.assignments.each do |assignment|
-            next if assignment_nodes_in_loop.none? do |assignment_node|
-                      assignment_node.equal?(assignment.node)
-                    end
-
-            assignment.reference!(node)
+          loop_assignments = variable.assignments.select do |assignment|
+            assignment_nodes_in_loop.include?(assignment.node)
           end
+          next unless loop_assignments.any?
+
+          reference_assignments(loop_assignments, node)
         end
       end
 
@@ -354,6 +360,17 @@ module RuboCop
         end
       end
 
+      def reference_assignments(loop_assignments, loop_node)
+        # If inside a branching statement, mark all as referenced.
+        # Otherwise, mark only the last assignment as referenced.
+        # Note that `rescue` must be considered as branching because of
+        # the `retry` keyword.
+        loop_assignments.each do |assignment|
+          assignment.reference!(loop_node) if assignment.node.each_ancestor(*BRANCH_NODES).any?
+        end
+        loop_assignments.last&.reference!(loop_node)
+      end
+
       def scanned_node?(node)
         scanned_nodes.include?(node)
       end

data/lib/rubocop/cops_documentation_generator.rb

@@ -7,6 +7,7 @@ require 'yard'
 # @api private
 class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
   include ::RuboCop::Cop::Documentation
+
   CopData = Struct.new(
     :cop, :description, :example_objects, :safety_objects, :see_objects, :config, keyword_init: true
   )
@@ -28,6 +29,12 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
   #
   #   CopsDocumentationGenerator.new(departments: ['Lint']).call
   #
+  # For plugin extensions, specify `:plugin_name` keyword as follows:
+  #
+  #   CopsDocumentationGenerator.new(
+  #     departments: ['Performance'], plugin_name: 'rubocop-performance'
+  #   ).call
+  #
   # You can append additional information:
   #
   #   callback = ->(data) { required_rails_version(data.cop) }
@@ -36,11 +43,16 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
   # This will insert the string returned from the lambda _after_ the section from RuboCop itself.
   # See `CopsDocumentationGenerator::STRUCTURE` for available sections.
   #
-  def initialize(departments: [], extra_info: {}, base_dir: Dir.pwd)
+  def initialize(departments: [], extra_info: {}, base_dir: Dir.pwd, plugin_name: nil)
     @departments = departments.map(&:to_sym).sort!
     @extra_info = extra_info
     @cops = RuboCop::Cop::Registry.global
     @config = RuboCop::ConfigLoader.default_configuration
+    # NOTE: For example, this prevents excessive plugin loading before another task executes,
+    # in cases where plugins are already loaded by `internal_investigation`.
+    if plugin_name && @config.loaded_plugins.none? { |plugin| plugin.about.name == plugin_name }
+      RuboCop::Plugin.integrate_plugins(RuboCop::Config.new, [plugin_name])
+    end
     @base_dir = base_dir
     @docs_path = "#{base_dir}/docs/modules/ROOT"
     FileUtils.mkdir_p("#{@docs_path}/pages")
@@ -182,10 +194,10 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
 
   def configurations(department, cop, cop_config)
     header = ['Name', 'Default value', 'Configurable values']
-    configs = cop_config
-              .each_key
-              .reject { |key| key.start_with?('Supported') }
-              .reject { |key| key.start_with?('AllowMultipleStyles') }
+    configs = cop_config.each_key.reject do |key|
+      key == 'AllowMultipleStyles' ||
+        (key != 'SupportedTypes' && key.start_with?('Supported'))
+    end
     return '' if configs.empty?
 
     content = configs.map do |name|
@@ -316,8 +328,12 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
   def print_cop_with_doc(cop) # rubocop:todo Metrics/AbcSize, Metrics/MethodLength
     cop_config = config.for_cop(cop)
     non_display_keys = %w[
-      AutoCorrect Description Enabled StyleGuide Reference Safe SafeAutoCorrect VersionAdded
-      VersionChanged
+      Enabled
+      Description
+      StyleGuide
+      Reference References
+      Safe SafeAutoCorrect AutoCorrect
+      VersionAdded VersionChanged
     ]
     parameters = cop_config.reject { |k| non_display_keys.include? k }
     description = 'No documentation'