rubocop 1.53.0 → 1.90.0

data/lib/rubocop/cop/team.rb

@@ -9,19 +9,37 @@ module RuboCop
     # For performance reasons, Team will first dispatch cops & forces in two groups,
     # first the ones needed for autocorrection (if any), then the rest
     # (unless autocorrections happened).
+    # rubocop:disable-next 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:
-        return mobilize(cop_or_classes, config, options) if cop_or_classes.first.is_a?(Class)
+        if cop_or_classes.first.is_a?(Class)
+          warn Rainbow(<<~WARNING).yellow, uplevel: 1
+            `Team.new` with cop classes is deprecated. Use `Team.mobilize` instead.
+          WARNING
+          return mobilize(cop_or_classes, config, options)
+        end
 
         super
       end
 
       # @return [Team] with cops assembled from the given `cop_classes`
       def self.mobilize(cop_classes, config, options = {})
-        cops = mobilize_cops(cop_classes, config, options)
-        new(cops, config, options)
+        if cop_classes.is_a?(Registry)
+          # Instantiate only the enabled cops so that disabled lazy-loaded cops are not loaded.
+          # The registry is kept on standby to mobilize a disabled cop when a comment directive
+          # opts it back in.
+          cops = cop_classes.enabled(config).map { |cop_class| cop_class.new(config, options) }
+          team = new(cops, config, options)
+          team.standby_registry = cop_classes
+          team
+        else
+          new(mobilize_cops(cop_classes, config, options), config, options)
+        end
       end
 
       # @return [Array<Cop::Base>]
@@ -50,12 +68,30 @@ 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
+
+      # Registry used to mobilize cops that were not instantiated because they are disabled in
+      # the config, when a comment directive opts them back in for a file.
+      #
+      # @api private
+      attr_writer :standby_registry
+
       alias updated_source_file? updated_source_file
 
       def initialize(cops, config = nil, options = {})
         @cops = cops
         @config = config
         @options = options
+        @standby_registry = nil
+        @standby_cops = {}
         reset
         @ready = true
         @registry = Registry.new(cops, options.dup)
@@ -74,67 +110,76 @@ module RuboCop
       # @deprecated. Use investigate
       # @return Array<offenses>
       def inspect_file(processed_source)
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `inspect_file` is deprecated. Use `investigate` instead.
+        WARNING
+
         investigate(processed_source).offenses
       end
 
       # @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
       def forces
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `forces` is deprecated.
+        WARNING
+
         @forces ||= self.class.forces_for(cops)
       end
 
       def external_dependency_checksum
-        keys = cops.filter_map(&:external_dependency_checksum)
-        Digest::SHA1.hexdigest(keys.join)
+        # The external dependency checksums are cached per RuboCop team so that
+        # the checksums don't need to be recomputed for each file.
+        @external_dependency_checksum ||= begin
+          keys = cops.filter_map(&:external_dependency_checksum)
+          Digest::SHA1.hexdigest(keys.join)
+        end
       end
 
       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
+        return unless corrector
+        return if corrector.empty?
 
-        new_source = autocorrect_report(report, original: original, offset: offset)
-
-        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
@@ -142,6 +187,7 @@ module RuboCop
 
         reset
         @cops.map!(&:ready)
+        @standby_cops.transform_values! { |cop| cop&.ready }
         @ready = true
       end
 
@@ -156,17 +202,101 @@ 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 = partition_by_correcting(on_duty)
+        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>]
+      # A cop whose unsafe correction is skipped still inserts todo comments
+      # under `--disable-uncorrectable`, so it must run with the correcting
+      # cops - correctors of the later `other_cops` round are never applied.
+      def partition_by_correcting(cops)
+        cops.partition do |cop|
+          cop.autocorrect? || cop.skipped_unsafe_correction_with_disable_uncorrectable?
+        end
+      end
+
       def roundup_relevant_cops(processed_source)
-        cops.select do |cop|
-          next true if processed_source.comment_config.cop_opted_in?(cop)
+        (cops + opted_in_standby_cops(processed_source)).select do |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)
         end
       end
 
+      # Cops that were not mobilized because they are disabled in the config,
+      # but are opted back in for the given file by an `enable` comment directive.
+      # Their classes are loaded on demand.
+      #
+      # @return [Array<cop>]
+      def opted_in_standby_cops(processed_source)
+        return [] unless @standby_registry
+
+        opted_in_names = processed_source.comment_config.opt_in_cops
+        return [] if opted_in_names.empty?
+
+        @mobilized_cop_names ||= Set.new(cops.map(&:cop_name))
+        opted_in_names.filter_map do |cop_name|
+          next if @mobilized_cop_names.include?(cop_name)
+
+          standby_cop(cop_name)
+        end
+      end
+
+      def standby_cop(cop_name)
+        return @standby_cops[cop_name] if @standby_cops.key?(cop_name)
+
+        cop_class = @standby_registry.find_by_cop_name(cop_name)
+
+        @standby_cops[cop_name] = cop_class&.new(@config, @options)
+      end
+
       def support_target_ruby_version?(cop)
         return true unless cop.class.respond_to?(:support_target_ruby_version?)
 
@@ -174,33 +304,43 @@ module RuboCop
       end
 
       def support_target_rails_version?(cop)
+        # In this case, the rails version was already checked by `#excluded_file?`
+        return true if defined?(RuboCop::Rails::TargetRailsVersion::USES_REQUIRES_GEM_API)
+
         return true unless cop.class.respond_to?(:support_target_rails_version?)
 
         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|
@@ -237,6 +377,8 @@ module RuboCop
 
           if cause.is_a?(Warning)
             handle_warning(cause, location)
+          elsif cause.is_a?(Force::HookError)
+            handle_error(cause.cause, location, cause.joining_cop)
           else
             handle_error(cause, location, error.cop)
           end
@@ -256,7 +398,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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     # This module contains a collection of useful utility methods.
-    # rubocop:disable Metrics/ModuleLength
+    # rubocop:disable-next Metrics/ModuleLength
     module Util
       include PathUtil
 
@@ -20,6 +20,10 @@ module RuboCop
 
       # @deprecated Use `ProcessedSource#line_with_comment?`, `contains_comment?` or similar
       def comment_lines?(node)
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `comment_lines?` is deprecated. Use `ProcessedSource#line_with_comment?`, `contains_comment?` or similar instead.
+        WARNING
+
         processed_source[line_range(node)].any? { |line| comment_line?(line) }
       end
 
@@ -28,10 +32,10 @@ module RuboCop
       end
 
       def parentheses?(node)
-        node.loc.respond_to?(:end) && node.loc.end && node.loc.end.is?(')')
+        node.loc_is?(:end, ')')
       end
 
-      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      # rubocop:disable-next Metrics/AbcSize, Metrics/MethodLength
       def add_parentheses(node, corrector)
         if node.args_type?
           arguments_range = node.source_range
@@ -51,7 +55,6 @@ module RuboCop
           corrector.insert_after(args_end(node), ')')
         end
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
       def any_descendant?(node, *types)
         if block_given?
@@ -70,9 +73,9 @@ module RuboCop
 
       def args_begin(node)
         loc = node.loc
-        selector = if node.super_type? || node.yield_type?
+        selector = if node.type?(:super, :yield)
                      loc.keyword
-                   elsif node.def_type? || node.defs_type?
+                   elsif node.any_def_type?
                      loc.name
                    else
                      loc.selector
@@ -113,10 +116,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
@@ -173,7 +175,9 @@ module RuboCop
       def same_line?(node1, node2)
         line1 = line(node1)
         line2 = line(node2)
-        line1 && line2 && line1 == line2
+        return false unless line1 && line2
+
+        line1 == line2
       end
 
       def indent(node, offset: 0)
@@ -187,17 +191,23 @@ module RuboCop
           enforced_style.sub(/^Enforced/, 'Supported').sub('Style', 'Styles')
       end
 
+      def parse_regexp(text)
+        Regexp::Parser.parse(text)
+      rescue Regexp::Parser::Error
+        # Upon encountering an invalid regular expression,
+        # we aim to proceed and identify any remaining potential offenses.
+        nil
+      end
+
       private
 
       def compatible_external_encoding_for?(src)
-        src = src.dup if RUBY_ENGINE == 'jruby'
-        src.force_encoding(Encoding.default_external).valid_encoding?
+        src.dup.force_encoding(Encoding.default_external).valid_encoding?
       end
 
       def include_or_equal?(source, target)
         source == target || (source.is_a?(Array) && source.include?(target))
       end
     end
-    # rubocop:enable Metrics/ModuleLength
   end
 end

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

@@ -9,9 +9,10 @@ module RuboCop
 
         MULTIPLE_LEFT_HAND_SIDE_TYPE = :mlhs
 
-        attr_reader :node, :variable, :referenced, :references
+        attr_reader :node, :variable, :referenced, :references, :reassigned
 
         alias referenced? referenced
+        alias reassigned? reassigned
 
         def initialize(node, variable)
           unless VARIABLE_ASSIGNMENT_TYPES.include?(node.type)
@@ -24,6 +25,7 @@ module RuboCop
           @variable = variable
           @referenced = false
           @references = []
+          @reassigned = false
         end
 
         def name
@@ -39,8 +41,14 @@ module RuboCop
           @referenced = true
         end
 
+        def reassigned!
+          return if referenced?
+
+          @reassigned = true
+        end
+
         def used?
-          @variable.captured_by_block? || @referenced
+          (!reassigned? && @variable.captured_by_block?) || @referenced
         end
 
         def regexp_named_capture?
@@ -102,10 +110,17 @@ module RuboCop
         end
 
         def multiple_assignment_node
-          grandparent_node = node.parent&.parent
-          return nil unless grandparent_node
+          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
           return nil unless grandparent_node.type == MULTIPLE_ASSIGNMENT_TYPE
-          return nil unless node.parent.type == MULTIPLE_LEFT_HAND_SIDE_TYPE
 
           grandparent_node
         end
@@ -118,9 +133,22 @@ module RuboCop
         end
 
         def for_assignment_node
-          return nil unless node.parent&.for_type?
+          return unless (parent_node = node.parent)
+          return parent_node if parent_node.for_type?
 
-          node.parent
+          grandparent_node = parent_node.parent
+          return grandparent_node if parent_node.mlhs_type? && grandparent_node&.for_type?
+
+          nil
+        end
+
+        def find_multiple_assignment_node(grandparent_node)
+          return unless grandparent_node.type == MULTIPLE_LEFT_HAND_SIDE_TYPE
+
+          parent = grandparent_node.parent
+          return parent if parent.type == MULTIPLE_ASSIGNMENT_TYPE
+
+          find_multiple_assignment_node(parent)
         end
       end
     end

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

@@ -74,7 +74,7 @@ module RuboCop
           def parent
             return @parent if instance_variable_defined?(:@parent)
 
-            @branch = Branch.of(control_node, scope: scope)
+            @parent = Branch.of(control_node, scope: scope)
           end
 
           def each_ancestor(include_self: false, &block)
@@ -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