rubocop 1.52.1 → 1.79.2

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

@@ -9,15 +9,17 @@ module RuboCop
       # The cop can be configured to ignore blocks passed to certain methods.
       #
       # You can set constructs you want to fold with `CountAsOne`.
-      # Available are: 'array', 'hash', 'heredoc', and 'method_call'. Each construct
-      # will be counted as one line regardless of its actual size.
       #
+      # Available are: 'array', 'hash', 'heredoc', and 'method_call'.
+      # Each construct will be counted as one line regardless of its actual size.
+      #
+      # NOTE: This cop does not apply for `Struct` definitions.
       #
       # 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.
       #
-      # @example CountAsOne: ['array', 'heredoc', 'method_call']
+      # @example CountAsOne: ['array', 'hash', 'heredoc', 'method_call']
       #
       #   something do
       #     array = [         # +1
@@ -25,7 +27,7 @@ module RuboCop
       #       2
       #     ]
       #
-      #     hash = {          # +3
+      #     hash = {          # +1
       #       key: 'value'
       #     }
       #
@@ -38,9 +40,8 @@ module RuboCop
       #       1,
       #       2
       #     )
-      #   end                 # 6 points
+      #   end                 # 4 points
       #
-      # NOTE: This cop does not apply for `Struct` definitions.
       class BlockLength < Base
         include CodeLength
         include AllowedMethods
@@ -56,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

@@ -3,12 +3,12 @@
 module RuboCop
   module Cop
     module Metrics
-      # Checks for excessive nesting of conditional and looping
-      # constructs.
+      # Checks for excessive nesting of conditional and looping constructs.
       #
-      # You can configure if blocks are considered using the `CountBlocks`
-      # option. When set to `false` (the default) blocks are not counted
-      # towards the nesting level. Set to `true` to count blocks as well.
+      # 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
+      # counted towards the nesting level. Set them to `true` to include these in the nesting level
+      # calculation as well.
       #
       # The maximum level of nesting allowed is configurable.
       class BlockNesting < Base
@@ -27,7 +27,7 @@ module RuboCop
 
         def check_nesting_level(node, max, current_level)
           if consider_node?(node)
-            current_level += 1 unless node.if_type? && node.elsif?
+            current_level += 1 if count_if_block?(node)
             if current_level > max
               self.max = current_level
               unless part_of_ignored_node?(node)
@@ -41,10 +41,18 @@ module RuboCop
           end
         end
 
+        def count_if_block?(node)
+          return true unless node.if_type?
+          return false if node.elsif?
+          return count_modifier_forms? if node.modifier_form?
+
+          true
+        end
+
         def consider_node?(node)
           return true if NESTING_BLOCKS.include?(node.type)
 
-          count_blocks? && (node.block_type? || node.numblock_type?)
+          count_blocks? && node.any_block_type?
         end
 
         def message(max)
@@ -52,7 +60,11 @@ module RuboCop
         end
 
         def count_blocks?
-          cop_config['CountBlocks']
+          cop_config.fetch('CountBlocks', false)
+        end
+
+        def count_modifier_forms?
+          cop_config.fetch('CountModifierForms', false)
         end
       end
     end

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

@@ -8,10 +8,13 @@ module RuboCop
       # The maximum allowed length is configurable.
       #
       # You can set constructs you want to fold with `CountAsOne`.
-      # Available are: 'array', 'hash', 'heredoc', and 'method_call'. Each construct
-      # will be counted as one line regardless of its actual size.
       #
-      # @example CountAsOne: ['array', 'heredoc', 'method_call']
+      # Available are: 'array', 'hash', 'heredoc', and 'method_call'.
+      # Each construct will be counted as one line regardless of its actual size.
+      #
+      # NOTE: This cop also applies for `Struct` definitions.
+      #
+      # @example CountAsOne: ['array', 'hash', 'heredoc', 'method_call']
       #
       #   class Foo
       #     ARRAY = [         # +1
@@ -19,7 +22,7 @@ module RuboCop
       #       2
       #     ]
       #
-      #     HASH = {          # +3
+      #     HASH = {          # +1
       #       key: 'value'
       #     }
       #
@@ -32,28 +35,23 @@ module RuboCop
       #       1,
       #       2
       #     )
-      #   end                 # 6 points
+      #   end                 # 4 points
       #
-      #
-      # NOTE: This cop also applies for `Struct` definitions.
       class ClassLength < Base
         include CodeLength
 
         def on_class(node)
           check_code_length(node)
         end
-        alias on_sclass on_class
 
-        def on_casgn(node)
-          parent = node.parent
+        def on_sclass(node)
+          return if node.each_ancestor(:class).any?
 
-          if parent&.assignment?
-            block_node = parent.children[1]
-          elsif parent&.parent&.masgn_type?
-            block_node = parent.parent.children[1]
-          else
-            _scope, _name, block_node = *node
-          end
+          on_class(node)
+        end
+
+        def on_casgn(node)
+          block_node = node.expression || find_expression_within_parent(node.parent)
 
           return unless block_node.respond_to?(:class_definition?) && block_node.class_definition?
 
@@ -65,6 +63,14 @@ module RuboCop
         def message(length, max_length)
           format('Class has too many lines. [%<length>d/%<max>d]', length: length, max: max_length)
         end
+
+        def find_expression_within_parent(parent)
+          if parent&.assignment?
+            parent.expression
+          elsif parent&.parent&.masgn_type?
+            parent.parent.expression
+          end
+        end
       end
     end
   end

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

@@ -52,12 +52,19 @@ module RuboCop
               'Prefer reading the data from an external source.'
         RESTRICT_ON_SEND = [:[]].freeze
 
+        # @!method set_const?(node)
+        def_node_matcher :set_const?, <<~PATTERN
+          (const {cbase nil?} :Set)
+        PATTERN
+
         def on_array(node)
           add_offense(node) if node.children.length >= collection_threshold
         end
         alias on_hash on_array
 
         def on_index(node)
+          return unless set_const?(node.receiver)
+
           add_offense(node) if node.arguments.length >= collection_threshold
         end
 

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

@@ -14,11 +14,14 @@ module RuboCop
       # and ||/or is shorthand for a sequence of ifs, so they also add one.
       # Loops can be said to have an exit condition, so they add one.
       # Blocks that are calls to builtin iteration methods
-      # (e.g. `ary.map{...}) also add one, others are ignored.
+      # (e.g. `ary.map{...}`) also add one, others are ignored.
+      #
+      # @example
       #
       #   def each_child_node(*types)               # count begins: 1
       #     unless block_given?                     # unless: +1
       #       return to_enum(__method__, *types)
+      #     end
       #
       #     children.each do |child|                # each{}: +1
       #       next unless child.is_a?(Node)         # unless: +1
@@ -33,7 +36,7 @@ module RuboCop
         include MethodComplexity
         include Utils::IteratingBlock
 
-        MSG = 'Cyclomatic complexity for %<method>s is too high. [%<complexity>d/%<max>d]'
+        MSG = 'Cyclomatic complexity for `%<method>s` is too high. [%<complexity>d/%<max>d]'
         COUNTED_NODES = %i[if while until for csend block block_pass
                            rescue when in_pattern and or or_asgn and_asgn].freeze
 

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

@@ -8,15 +8,16 @@ module RuboCop
       # The maximum allowed length is configurable.
       #
       # You can set constructs you want to fold with `CountAsOne`.
-      # Available are: 'array', 'hash', 'heredoc', and 'method_call'. Each construct
-      # will be counted as one line regardless of its actual size.
+      #
+      # Available are: 'array', 'hash', 'heredoc', and 'method_call'.
+      # Each construct will be counted as one line regardless of its actual size.
       #
       # 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.
       #
-      # @example CountAsOne: ['array', 'heredoc', 'method_call']
+      # @example CountAsOne: ['array', 'hash', 'heredoc', 'method_call']
       #
       #   def m
       #     array = [       # +1
@@ -24,7 +25,7 @@ module RuboCop
       #       2
       #     ]
       #
-      #     hash = {        # +3
+      #     hash = {        # +1
       #       key: 'value'
       #     }
       #
@@ -37,7 +38,7 @@ module RuboCop
       #       1,
       #       2
       #     )
-      #   end               # 6 points
+      #   end               # 4 points
       #
       class MethodLength < Base
         include CodeLength
@@ -47,24 +48,32 @@ module RuboCop
         LABEL = 'Method'
 
         def on_def(node)
-          return if allowed_method?(node.method_name) || matches_allowed_pattern?(node.method_name)
+          return if allowed?(node.method_name)
 
           check_code_length(node)
         end
         alias on_defs on_def
 
         def on_block(node)
-          return unless node.send_node.method?(:define_method)
+          return unless node.method?(:define_method)
+
+          method_name = node.send_node.first_argument
+          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
 
         def cop_label
           LABEL
         end
+
+        def allowed?(method_name)
+          allowed_method?(method_name) || matches_allowed_pattern?(method_name)
+        end
       end
     end
   end

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

@@ -8,10 +8,11 @@ module RuboCop
       # The maximum allowed length is configurable.
       #
       # You can set constructs you want to fold with `CountAsOne`.
-      # Available are: 'array', 'hash', 'heredoc', and 'method_call'. Each construct
-      # will be counted as one line regardless of its actual size.
       #
-      # @example CountAsOne: ['array', 'heredoc', 'method_call']
+      # Available are: 'array', 'hash', 'heredoc', and 'method_call'.
+      # Each construct will be counted as one line regardless of its actual size.
+      #
+      # @example CountAsOne: ['array', 'hash', 'heredoc', 'method_call']
       #
       #   module M
       #     ARRAY = [         # +1
@@ -19,7 +20,7 @@ module RuboCop
       #       2
       #     ]
       #
-      #     HASH = {          # +3
+      #     HASH = {          # +1
       #       key: 'value'
       #     }
       #
@@ -32,7 +33,7 @@ module RuboCop
       #       1,
       #       2
       #     )
-      #   end                 # 6 points
+      #   end                 # 4 points
       #
       class ModuleLength < Base
         include CodeLength
@@ -49,7 +50,7 @@ module RuboCop
 
         # @!method module_definition?(node)
         def_node_matcher :module_definition?, <<~PATTERN
-          (casgn nil? _ ({block numblock} (send (const {nil? cbase} :Module) :new) ...))
+          (casgn nil? _ (any_block (send (const {nil? cbase} :Module) :new) ...))
         PATTERN
 
         def message(length, max_length)

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

@@ -27,7 +27,7 @@ module RuboCop
       #     end                           # ===
       #   end                             # 7 complexity points
       class PerceivedComplexity < CyclomaticComplexity
-        MSG = 'Perceived complexity for %<method>s is too high. [%<complexity>d/%<max>d]'
+        MSG = 'Perceived complexity for `%<method>s` is too high. [%<complexity>d/%<max>d]'
 
         COUNTED_NODES = (CyclomaticComplexity::COUNTED_NODES - [:when] + [:case]).freeze
 

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

@@ -95,7 +95,7 @@ module RuboCop
           def compound_assignment(node)
             # Methods setter cannot be detected for multiple assignments
             # and shorthand assigns, so we'll count them here instead
-            children = node.masgn_type? ? node.children[0].children : node.children
+            children = node.masgn_type? ? node.assignments : node.children
 
             will_be_miscounted = children.count do |child|
               child.respond_to?(:setter_method?) && !child.setter_method?

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

@@ -9,8 +9,8 @@ module RuboCop
           extend NodePattern::Macros
           include Util
 
-          FOLDABLE_TYPES = %i[array hash heredoc send csend].freeze
-          CLASSLIKE_TYPES = %i[class module sclass].freeze
+          FOLDABLE_TYPES = %i[array hash heredoc method_call].freeze
+          CLASSLIKE_TYPES = %i[class module].freeze
           private_constant :FOLDABLE_TYPES, :CLASSLIKE_TYPES
 
           def initialize(node, processed_source, count_comments: false, foldable_types: [])
@@ -43,16 +43,16 @@ module RuboCop
             types.map do |type|
               case type
               when :array
-                ->(node) { node.array_type? }
+                lambda(&:array_type?)
               when :hash
-                ->(node) { node.hash_type? }
+                lambda(&:hash_type?)
               when :heredoc
                 ->(node) { heredoc_node?(node) }
               when :method_call
-                ->(node) { node.call_type? }
+                lambda(&:call_type?)
               else
-                raise ArgumentError, "Unknown foldable type: #{type.inspect}. " \
-                                     "Valid foldable types are: #{FOLDABLE_TYPES.join(', ')}."
+                raise Warning, "Unknown foldable type: #{type.inspect}. " \
+                               "Valid foldable types are: #{FOLDABLE_TYPES.join(', ')}."
               end
             end
           end
@@ -63,7 +63,7 @@ module RuboCop
             types
           end
 
-          def code_length(node)
+          def code_length(node) # rubocop:disable Metrics/MethodLength
             if classlike_node?(node)
               classlike_code_length(node)
             elsif heredoc_node?(node)
@@ -72,7 +72,14 @@ module RuboCop
               body = extract_body(node)
               return 0 unless body
 
-              body.source.each_line.count { |line| !irrelevant_line?(line) }
+              source =
+                if node_with_heredoc?(body)
+                  source_from_node_with_heredoc(body)
+                else
+                  body.source.lines
+                end
+
+              source.count { |line| !irrelevant_line?(line) }
             end
           end
 
@@ -138,11 +145,10 @@ module RuboCop
 
           def extract_body(node)
             case node.type
-            when :class, :module, :block, :numblock, :def, :defs
+            when :class, :module, :sclass, :block, :numblock, :itblock, :def, :defs
               node.body
             when :casgn
-              _scope, _name, value = *node
-              extract_body(value)
+              extract_body(node.expression)
             else
               node
             end
@@ -175,6 +181,27 @@ module RuboCop
           def another_args?(node)
             node.call_type? && node.arguments.count > 1
           end
+
+          def node_with_heredoc?(node)
+            node.each_descendant(:str, :dstr).any? { |descendant| heredoc_node?(descendant) }
+          end
+
+          def source_from_node_with_heredoc(node)
+            last_line = -1
+            node.each_descendant do |descendant|
+              next unless descendant.source
+
+              descendant_last_line =
+                if heredoc_node?(descendant)
+                  descendant.loc.heredoc_end.line
+                else
+                  descendant.last_line
+                end
+
+              last_line = [last_line, descendant_last_line].max
+            end
+            @processed_source[(node.first_line - 1)..(last_line - 1)]
+          end
         end
       end
     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/migration/department_name.rb

@@ -16,7 +16,7 @@ module RuboCop
         # The token that makes up a disable comment.
         # The allowed specification for comments after `# rubocop: disable` is
         # `DepartmentName/CopName` or` all`.
-        DISABLING_COPS_CONTENT_TOKEN = %r{[A-z]+/[A-z]+|all}.freeze
+        DISABLING_COPS_CONTENT_TOKEN = %r{[A-Za-z]+/[A-Za-z]+|all}.freeze
 
         def on_new_investigation
           processed_source.comments.each do |comment|
@@ -67,7 +67,7 @@ module RuboCop
         end
 
         def contain_unexpected_character_for_department_name?(name)
-          name.match?(%r{[^A-z/, ]})
+          name.match?(%r{[^A-Za-z/, ]})
         end
 
         def qualified_legacy_cop_name(cop_name)

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

@@ -5,10 +5,10 @@ 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
@@ -65,8 +65,12 @@ module RuboCop
         inner.begin_pos >= outer.begin_pos && inner.end_pos <= outer.end_pos
       end
 
-      # @deprecated Use processed_source.comment_at_line(line)
-      def end_of_line_comment(line)
+      # @deprecated Use processed_source.line_with_comment?(line)
+      def end_of_line_comment(line) # rubocop:disable Naming/PredicateMethod
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `end_of_line_comment` is deprecated. Use `processed_source.line_with_comment?` instead.
+        WARNING
+
         processed_source.line_with_comment?(line)
       end
 

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

@@ -15,7 +15,13 @@ module RuboCop
       end
 
       # @deprecated Use allowed_method? instead
-      alias ignored_method? allowed_method?
+      def ignored_method?
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `ignored_method?` is deprecated. Use `allowed_method?` instead.
+        WARNING
+
+        allowed_method?
+      end
 
       # @api public
       def allowed_methods

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

@@ -18,14 +18,26 @@ module RuboCop
       end
 
       # @deprecated Use allowed_line? instead
-      alias ignored_line? allowed_line?
+      def ignored_line?(line)
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `ignored_line?` is deprecated. Use `allowed_line?` instead.
+        WARNING
+
+        allowed_line?(line)
+      end
 
       def matches_allowed_pattern?(line)
         allowed_patterns.any? { |pattern| Regexp.new(pattern).match?(line) }
       end
 
-      # @deprecated Use matches_allowed_pattern?? instead
-      alias matches_ignored_pattern? matches_allowed_pattern?
+      # @deprecated Use matches_allowed_pattern? instead
+      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?(line)
+      end
 
       def allowed_patterns
         # Since there could be a pattern specified in the default config, merge the two

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

@@ -4,8 +4,6 @@ module RuboCop
   module Cop
     # Representation of an annotation comment in source code (eg. `# TODO: blah blah blah`).
     class AnnotationComment
-      extend Forwardable
-
       attr_reader :comment, :margin, :keyword, :colon, :space, :note
 
       # @param [Parser::Source::Comment] comment

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

@@ -17,9 +17,7 @@ module RuboCop
       alias on_and_asgn on_lvasgn
 
       def on_send(node)
-        rhs = extract_rhs(node)
-
-        return unless rhs
+        return unless (rhs = extract_rhs(node))
 
         check_assignment(node, rhs)
       end
@@ -27,17 +25,11 @@ module RuboCop
       module_function
 
       def extract_rhs(node)
-        if node.casgn_type?
-          _scope, _lhs, rhs = *node
-        elsif node.op_asgn_type?
-          _lhs, _op, rhs = *node
-        elsif node.call_type?
-          rhs = node.last_argument
+        if node.call_type?
+          node.last_argument
         elsif node.assignment?
-          _lhs, rhs = *node
+          node.expression
         end
-
-        rhs
       end
     end
   end