rubocop 1.71.1 → 1.92.1

data/lib/rubocop/cop/metrics/block_length.rb

@@ -17,7 +17,7 @@ module RuboCop
       #
       # NOTE: The `ExcludedMethods` configuration is deprecated and only kept
       # for backwards compatibility. Please use `AllowedMethods` and `AllowedPatterns`
-      # instead. By default, there are no methods to allowed.
+      # instead. By default, there are no allowed methods.
       #
       # @example CountAsOne: ['array', 'hash', 'heredoc', 'method_call']
       #
@@ -57,6 +57,7 @@ module RuboCop
           check_code_length(node)
         end
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 

data/lib/rubocop/cop/metrics/block_nesting.rb

@@ -4,6 +4,8 @@ module RuboCop
   module Cop
     module Metrics
       # Checks for excessive nesting of conditional and looping constructs.
+      # Deeply nested code is harder to read, understand, and maintain.
+      # Extracting nested logic into methods improves clarity.
       #
       # You can configure if blocks are considered using the `CountBlocks` and `CountModifierForms`
       # options. When both are set to `false` (the default) blocks and modifier forms are not
@@ -11,6 +13,27 @@ module RuboCop
       # calculation as well.
       #
       # The maximum level of nesting allowed is configurable.
+      #
+      # @example Max: 3 (default)
+      #   # bad
+      #   if condition1
+      #     if condition2
+      #       if condition3
+      #         if condition4
+      #           do_something
+      #         end
+      #       end
+      #     end
+      #   end
+      #
+      #   # good
+      #   if condition1
+      #     if condition2
+      #       if condition3
+      #         do_something
+      #       end
+      #     end
+      #   end
       class BlockNesting < Base
         NESTING_BLOCKS = %i[case case_match if while while_post until until_post for resbody].freeze
 

data/lib/rubocop/cop/metrics/class_length.rb

@@ -40,6 +40,8 @@ module RuboCop
       class ClassLength < Base
         include CodeLength
 
+        LABEL = 'Class'
+
         def on_class(node)
           check_code_length(node)
         end
@@ -60,8 +62,8 @@ module RuboCop
 
         private
 
-        def message(length, max_length)
-          format('Class has too many lines. [%<length>d/%<max>d]', length: length, max: max_length)
+        def cop_label
+          LABEL
         end
 
         def find_expression_within_parent(parent)

data/lib/rubocop/cop/metrics/collection_literal_length.rb

@@ -75,7 +75,7 @@ module RuboCop
         private
 
         def collection_threshold
-          cop_config.fetch('LengthThreshold', Float::INFINITY)
+          cop_config.fetch('Max', Float::INFINITY)
         end
       end
     end

data/lib/rubocop/cop/metrics/cyclomatic_complexity.rb

@@ -48,10 +48,6 @@ module RuboCop
 
           1
         end
-
-        def count_block?(block)
-          KNOWN_ITERATING_METHODS.include? block.method_name
-        end
       end
     end
   end

data/lib/rubocop/cop/metrics/method_length.rb

@@ -15,7 +15,7 @@ module RuboCop
       # NOTE: The `ExcludedMethods` and `IgnoredMethods` configuration is
       # deprecated and only kept for backwards compatibility.
       # Please use `AllowedMethods` and `AllowedPatterns` instead.
-      # By default, there are no methods to allowed.
+      # By default, there are no allowed methods.
       #
       # @example CountAsOne: ['array', 'hash', 'heredoc', 'method_call']
       #
@@ -58,11 +58,12 @@ module RuboCop
           return unless node.method?(:define_method)
 
           method_name = node.send_node.first_argument
-          return if method_name.basic_literal? && allowed?(method_name.value)
+          return if method_name&.basic_literal? && allowed?(method_name.value)
 
           check_code_length(node)
         end
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 

data/lib/rubocop/cop/metrics/module_length.rb

@@ -38,6 +38,8 @@ module RuboCop
       class ModuleLength < Base
         include CodeLength
 
+        LABEL = 'Module'
+
         def on_module(node)
           check_code_length(node)
         end
@@ -53,8 +55,8 @@ module RuboCop
           (casgn nil? _ (any_block (send (const {nil? cbase} :Module) :new) ...))
         PATTERN
 
-        def message(length, max_length)
-          format('Module has too many lines. [%<length>d/%<max>d]', length: length, max: max_length)
+        def cop_label
+          LABEL
         end
       end
     end

data/lib/rubocop/cop/metrics/perceived_complexity.rb

@@ -12,9 +12,15 @@ module RuboCop
       # nodes count. In contrast to the CyclomaticComplexity cop, this cop
       # considers `else` nodes as adding complexity.
       #
+      # A `case`/`in` branch whose pattern is a simple literal (e.g. `in 1`, `in "red"`, `in 1..10`)
+      # or a constant/type (e.g. `in Integer`) and has no guard is just as easy to read as a `when`
+      # branch, so it is discounted the same way. Branches with structural patterns (e.g. array,
+      # hash, or find patterns), bindings, alternatives, or a guard add the full complexity of
+      # a decision point.
+      #
       # @example
       #
-      #   def my_method                   # 1
+      #   def example_1                   # 1
       #     if cond                       # 1
       #       case var                    # 2 (0.8 + 4 * 0.2, rounded)
       #       when 1 then func_one
@@ -26,33 +32,57 @@ module RuboCop
       #       do_something until a && b   # 2
       #     end                           # ===
       #   end                             # 7 complexity points
+      #
+      #   def example_2                   # 1
+      #     case color                    # 1 (3 * 0.2, rounded)
+      #     in "red" then func_red
+      #     in "blue" then func_blue
+      #     in "green" then func_green
+      #     end                           # ===
+      #   end                             # 2 complexity points
       class PerceivedComplexity < CyclomaticComplexity
         MSG = 'Perceived complexity for `%<method>s` is too high. [%<complexity>d/%<max>d]'
 
-        COUNTED_NODES = (CyclomaticComplexity::COUNTED_NODES - [:when] + [:case]).freeze
+        COUNTED_NODES = (
+          CyclomaticComplexity::COUNTED_NODES - %i[when in_pattern] + %i[case case_match]
+        ).freeze
 
         private
 
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         def complexity_score_for(node)
           case node.type
           when :case
-            # If cond is nil, that means each when has an expression that
-            # evaluates to true or false. It's just an alternative to
-            # if/elsif/elsif... so the when nodes count.
+            # If cond is nil, that means each when has an expression that evaluates to true or
+            # false. It's just an alternative to if/elsif/elsif... so the when nodes count.
             nb_branches = node.when_branches.length + (node.else_branch ? 1 : 0)
             if node.condition.nil?
               nb_branches
             else
-              # Otherwise, the case node gets 0.8 complexity points and each
-              # when gets 0.2.
+              # Otherwise, the case node gets 0.8 complexity points and each when gets 0.2.
               ((nb_branches * 0.2) + 0.8).round
             end
+          when :case_match
+            # Simple `in` branches are discounted like `when`, while structural patterns keep
+            # the full complexity of a decision point.
+            score = node.in_pattern_branches.sum { |branch| simple_in_pattern?(branch) ? 0.2 : 1 }
+            score += 0.2 if node.else_branch
+            score.round
           when :if
             node.else? && !node.elsif? ? 2 : 1
           else
             super
           end
         end
+
+        def simple_in_pattern?(in_pattern_node)
+          # `in_pattern_node.children[1]` is the guard (`if`/`unless`), or `nil`.
+          return false unless in_pattern_node.children[1].nil?
+
+          # A scalar literal, a literal range, or a constant/type is as easy to read as a `when`.
+          pattern = in_pattern_node.pattern
+          pattern.literal? || pattern.const_type?
+        end
       end
     end
   end

data/lib/rubocop/cop/metrics/utils/abc_size_calculator.rb

@@ -84,7 +84,10 @@ module RuboCop
           end
 
           def assignment?(node)
-            return compound_assignment(node) if node.masgn_type? || node.shorthand_asgn?
+            if node.masgn_type? || node.shorthand_asgn?
+              compound_assignment(node)
+              return false
+            end
 
             node.for_type? ||
               (node.respond_to?(:setter_method?) && node.setter_method?) ||
@@ -101,8 +104,6 @@ module RuboCop
               child.respond_to?(:setter_method?) && !child.setter_method?
             end
             @assignment += will_be_miscounted
-
-            false
           end
 
           def simple_assignment?(node)

data/lib/rubocop/cop/metrics/utils/code_length_calculator.rb

@@ -145,7 +145,7 @@ module RuboCop
 
           def extract_body(node)
             case node.type
-            when :class, :module, :sclass, :block, :numblock, :def, :defs
+            when :class, :module, :sclass, :block, :numblock, :itblock, :def, :defs
               node.body
             when :casgn
               extract_body(node.expression)
@@ -189,7 +189,7 @@ module RuboCop
           def source_from_node_with_heredoc(node)
             last_line = -1
             node.each_descendant do |descendant|
-              next unless descendant.source
+              next if descendant.loc.nil? || descendant.source_range.nil?
 
               descendant_last_line =
                 if heredoc_node?(descendant)

data/lib/rubocop/cop/metrics/utils/iterating_block.rb

@@ -43,7 +43,7 @@ module RuboCop
             end
           end
 
-          # Returns true iff name is a known iterating type (e.g. :each, :transform_values)
+          # Returns true only when name is a known iterating type (e.g. :each, :transform_values).
           def iterating_method?(name)
             KNOWN_ITERATING_METHODS.include? name
           end

data/lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb

@@ -26,6 +26,13 @@ module RuboCop
           extend NodePattern::Macros
           include RuboCop::AST::Sexp
 
+          VAR_SETTER_TO_GETTER = {
+            lvasgn: :lvar,
+            ivasgn: :ivar,
+            cvasgn: :cvar,
+            gvasgn: :gvar
+          }.freeze
+
           # Plug into the calculator
           def initialize(node, discount_repeated_attributes: false)
             super(node)
@@ -114,13 +121,6 @@ module RuboCop
             calls.fetch(value) { yield [calls, value] }
           end
 
-          VAR_SETTER_TO_GETTER = {
-            lvasgn: :lvar,
-            ivasgn: :ivar,
-            cvasgn: :cvar,
-            gvasgn: :gvar
-          }.freeze
-
           # @returns `[receiver, method | nil]` for the given setter `node`
           # or `nil` if it is not a setter.
           def setter_to_getter(node)

data/lib/rubocop/cop/metrics.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Cops for the `Metrics` department. The department's cops are registered for lazy loading
+    # and their files are loaded on demand.
+    module Metrics
+      extend LazyLoader
+
+      register_cop :CyclomaticComplexity, "#{__dir__}/metrics/cyclomatic_complexity"
+      register_cop :AbcSize, "#{__dir__}/metrics/abc_size"
+      register_cop :BlockLength, "#{__dir__}/metrics/block_length"
+      register_cop :BlockNesting, "#{__dir__}/metrics/block_nesting"
+      register_cop :ClassLength, "#{__dir__}/metrics/class_length"
+      register_cop :CollectionLiteralLength, "#{__dir__}/metrics/collection_literal_length"
+      register_cop :MethodLength, "#{__dir__}/metrics/method_length"
+      register_cop :ModuleLength, "#{__dir__}/metrics/module_length"
+      register_cop :ParameterLists, "#{__dir__}/metrics/parameter_lists"
+      register_cop :PerceivedComplexity, "#{__dir__}/metrics/perceived_complexity"
+
+      # Utility classes for `Metrics` department cops.
+      module Utils
+        autoload :AbcSizeCalculator, "#{__dir__}/metrics/utils/abc_size_calculator"
+        autoload :CodeLengthCalculator, "#{__dir__}/metrics/utils/code_length_calculator"
+        autoload :IteratingBlock, "#{__dir__}/metrics/utils/iterating_block"
+        autoload :RepeatedAttributeDiscount, "#{__dir__}/metrics/utils/repeated_attribute_discount"
+        autoload :RepeatedCsendDiscount, "#{__dir__}/metrics/utils/repeated_csend_discount"
+      end
+    end
+  end
+end

data/lib/rubocop/cop/migration/department_name.rb

@@ -1,10 +1,20 @@
 # frozen_string_literal: true
 
+# Lint/RedundantCopDisableDirective needs to be disabled so as
+# to be able to provide examples of rubocop:disable comments.
+# rubocop:disable-next Lint/RedundantCopDisableDirective -- the examples below read as real directives
 module RuboCop
   module Cop
     module Migration
-      # Check that cop names in rubocop:disable comments are given with
+      # Checks that cop names in rubocop:disable comments are given with
       # department name.
+      #
+      # @example
+      #   # bad
+      #   # rubocop:disable AbcSize
+      #
+      #   # good
+      #   # rubocop:disable Metrics/AbcSize
       class DepartmentName < Base
         include RangeHelp
         extend AutoCorrector
@@ -40,10 +50,6 @@ module RuboCop
 
         private
 
-        def disable_comment_offset
-          Regexp.last_match(1).length
-        end
-
         def check_cop_name(name, comment, offset)
           start = comment.source_range.begin_pos + offset
           range = range_between(start, start + name.length)

data/lib/rubocop/cop/migration.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Cops for the `Migration` department. The department's cops are registered for lazy loading
+    # and their files are loaded on demand.
+    module Migration
+      extend LazyLoader
+
+      register_cop :DepartmentName, "#{__dir__}/migration/department_name"
+    end
+  end
+end

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

@@ -5,16 +5,20 @@ module RuboCop
     # This module checks for nodes that should be aligned to the left or right.
     # This amount is determined by the instance variable @column_delta.
     module Alignment
-      private
-
       SPACE = ' '
 
+      private
+
       attr_reader :column_delta
 
       def configured_indentation_width
         cop_config['IndentationWidth'] || config.for_cop('Layout/IndentationWidth')['Width'] || 2
       end
 
+      def using_tabs?
+        config.for_cop('Layout/IndentationStyle')['EnforcedStyle'] == 'tabs'
+      end
+
       def indentation(node)
         offset(node) + (SPACE * configured_indentation_width)
       end
@@ -66,7 +70,7 @@ module RuboCop
       end
 
       # @deprecated Use processed_source.line_with_comment?(line)
-      def end_of_line_comment(line)
+      def end_of_line_comment(line) # rubocop:disable Naming/PredicateMethod -- a deprecated shim kept under its original name
         warn Rainbow(<<~WARNING).yellow, uplevel: 1
           `end_of_line_comment` is deprecated. Use `processed_source.line_with_comment?` instead.
         WARNING

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

@@ -25,11 +25,11 @@ module RuboCop
 
       # @api public
       def allowed_methods
-        if cop_config_deprecated_values.any?(Regexp)
-          cop_config_allowed_methods
-        else
-          cop_config_allowed_methods + cop_config_deprecated_values
-        end
+        @allowed_methods ||= if cop_config_deprecated_values.any?(Regexp)
+                               cop_config_allowed_methods
+                             else
+                               cop_config_allowed_methods + cop_config_deprecated_values
+                             end
       end
 
       def cop_config_allowed_methods

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

@@ -18,25 +18,25 @@ module RuboCop
       end
 
       # @deprecated Use allowed_line? instead
-      def ignored_line?
+      def ignored_line?(line)
         warn Rainbow(<<~WARNING).yellow, uplevel: 1
           `ignored_line?` is deprecated. Use `allowed_line?` instead.
         WARNING
 
-        allowed_line?
+        allowed_line?(line)
       end
 
       def matches_allowed_pattern?(line)
-        allowed_patterns.any? { |pattern| Regexp.new(pattern).match?(line) }
+        allowed_pattern_regexps.any? { |pattern| pattern.match?(line) }
       end
 
       # @deprecated Use matches_allowed_pattern? instead
-      def matches_ignored_pattern?
+      def matches_ignored_pattern?(line)
         warn Rainbow(<<~WARNING).yellow, uplevel: 1
           `matches_ignored_pattern?` is deprecated. Use `matches_allowed_pattern?` instead.
         WARNING
 
-        matches_allowed_pattern?
+        matches_allowed_pattern?(line)
       end
 
       def allowed_patterns
@@ -49,6 +49,10 @@ module RuboCop
         end
       end
 
+      def allowed_pattern_regexps
+        @allowed_pattern_regexps ||= allowed_patterns.map { |pattern| Regexp.new(pattern) }
+      end
+
       def cop_config_patterns_values
         @cop_config_patterns_values ||=
           Array(cop_config.fetch('AllowedPatterns', [])) +

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

@@ -45,7 +45,7 @@ module RuboCop
         match.captures
       end
 
-      KEYWORDS_REGEX_CACHE = {} # rubocop:disable Style/MutableConstant
+      KEYWORDS_REGEX_CACHE = {} # rubocop:disable Style/MutableConstant -- a cache, written to at runtime
       private_constant :KEYWORDS_REGEX_CACHE
 
       def regex

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

@@ -48,7 +48,7 @@ module RuboCop
 
           args = process_args(node.arguments)
           return extract_breakable_node_from_elements(node, args, max)
-        elsif node.def_type?
+        elsif node.any_def_type?
           return extract_breakable_node_from_elements(node, node.arguments, max)
         elsif node.type?(:array, :hash)
           return extract_breakable_node_from_elements(node, node.children, max)
@@ -61,11 +61,13 @@ module RuboCop
       # @api private
       def extract_breakable_node_from_elements(node, elements, max)
         return unless breakable_collection?(node, elements)
-        return if safe_to_ignore?(node)
 
+        # Check the cheap conditions first, `safe_to_ignore?` may traverse all elements of
+        # a containing collection.
         line = processed_source.lines[node.first_line - 1]
+        return if max && line.length <= max
         return if processed_source.line_with_comment?(node.loc.line)
-        return if line.length <= max
+        return if safe_to_ignore?(node)
 
         extract_first_element_over_column_limit(node, elements, max)
       end
@@ -74,11 +76,7 @@ module RuboCop
       def extract_first_element_over_column_limit(node, elements, max)
         line = node.first_line
 
-        # If a `send` or `csend` node is not parenthesized, don't move the first element, because it
-        # can result in changed behavior or a syntax error.
-        if node.call_type? && !node.parenthesized? && !first_argument_is_heredoc?(node)
-          elements = elements.drop(1)
-        end
+        elements = elements.drop(1) unless first_element_movable?(node)
 
         i = 0
         i += 1 while within_column_limit?(elements[i], max, line)
@@ -91,23 +89,35 @@ module RuboCop
       end
 
       # @api private
-      def first_argument_is_heredoc?(node)
-        first_argument = node.first_argument
+      # If a method call or definition is not parenthesized, the first element cannot be moved,
+      # because it can result in changed behavior or a syntax error.
+      def first_element_movable?(node)
+        return !node.arguments.loc.begin.nil? if node.any_def_type?
+        return true if !node.call_type? || node.parenthesized?
 
-        first_argument.respond_to?(:heredoc?) && first_argument.heredoc?
+        node.first_argument.respond_to?(:heredoc?) && node.first_argument.heredoc?
       end
 
       # @api private
       # If a `send` or `csend` node contains a heredoc argument, splitting cannot happen
       # after the heredoc or else it will cause a syntax error.
       def shift_elements_for_heredoc_arg(node, elements, index)
-        return index unless node.type?(:call, :array)
+        return index unless node.type?(:call, :array, :hash)
+        return index unless (heredoc_pos = heredoc_begin_position(node))
+
+        last_safe = elements.rindex { |element| element.source_range.begin_pos <= heredoc_pos }
+        return nil if last_safe.nil? ||
+                      (last_safe.zero? && elements.first.source_range.end_pos > heredoc_pos)
 
-        heredoc_index = elements.index { |arg| arg.respond_to?(:heredoc?) && arg.heredoc? }
-        return index unless heredoc_index
-        return nil if heredoc_index.zero?
+        [index, last_safe + 1].min
+      end
 
-        heredoc_index >= index ? index : heredoc_index + 1
+      # @api private
+      def heredoc_begin_position(node)
+        children = node.call_type? ? node.arguments : node.children
+        children.flat_map { |child| [child, *child.each_descendant(:any_str)] }
+                .find { |descendant| descendant.type?(:any_str) && descendant.heredoc? }
+                &.source_range&.begin_pos
       end
 
       # @api private
@@ -126,9 +136,7 @@ module RuboCop
         # or redundant edits, we only mark one offense at a time.
         return true if contained_by_breakable_collection_on_same_line?(node)
 
-        return true if contained_by_multiline_collection_that_could_be_broken_up?(node)
-
-        false
+        contained_by_multiline_collection_that_could_be_broken_up?(node)
       end
 
       # @api private
@@ -143,9 +151,7 @@ module RuboCop
         # break before the second argument and the rest of the
         # argument will get auto-formatted onto separate lines
         # by other cops.
-        has_second_element = elements.length >= 2
-
-        starts_with_bracket && has_second_element
+        starts_with_bracket && elements.length >= 2
       end
 
       # @api private
@@ -173,20 +179,36 @@ module RuboCop
         node.each_ancestor.find do |ancestor|
           if ancestor.type?(:hash, :array) &&
              breakable_collection?(ancestor, ancestor.children)
-            return children_could_be_broken_up?(ancestor.children)
+            return children_could_be_broken_up?(ancestor, ancestor.children)
           end
 
           next unless ancestor.call_type?
 
           args = process_args(ancestor.arguments)
-          return children_could_be_broken_up?(args) if breakable_collection?(ancestor, args)
+          if breakable_collection?(ancestor, args)
+            return children_could_be_broken_up?(ancestor, args)
+          end
         end
 
         false
       end
 
       # @api private
-      def children_could_be_broken_up?(children)
+      # The result depends only on the given node, but the check may traverse all children of
+      # a large collection and is repeated for each contained element, so memoize it per node.
+      def children_could_be_broken_up?(node, children)
+        if @check_line_breakable_processed_source != processed_source
+          @check_line_breakable_processed_source = processed_source
+          @children_could_be_broken_up_cache = {}.compare_by_identity
+        end
+
+        @children_could_be_broken_up_cache.fetch(node) do
+          @children_could_be_broken_up_cache[node] = compute_children_could_be_broken_up?(children)
+        end
+      end
+
+      # @api private
+      def compute_children_could_be_broken_up?(children)
         return false if all_on_same_line?(children)
 
         last_seen_line = -1
@@ -220,14 +242,14 @@ module RuboCop
 
       # @api private
       def already_on_multiple_lines?(node)
-        return node.first_line != node.last_argument.last_line if node.def_type?
+        return node.first_line != node.last_argument.last_line if node.any_def_type?
 
-        !node.single_line?
+        node.multiline?
       end
 
       def chained_to_heredoc?(node)
         while (node = node.receiver)
-          return true if node.type?(:str, :dstr, :xstr) && node.heredoc?
+          return true if node.any_str_type? && node.heredoc?
         end
 
         false