rubocop 1.29.1 → 1.46.0

data/lib/rubocop/cop/lint/useless_rescue.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for useless `rescue`s, which only reraise rescued exceptions.
+      #
+      # @example
+      #   # bad
+      #   def foo
+      #     do_something
+      #   rescue
+      #     raise
+      #   end
+      #
+      #   # bad
+      #   def foo
+      #     do_something
+      #   rescue => e
+      #     raise # or 'raise e', or 'raise $!', or 'raise $ERROR_INFO'
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     do_something
+      #   rescue
+      #     do_cleanup
+      #     raise
+      #   end
+      #
+      #   # bad (latest rescue)
+      #   def foo
+      #     do_something
+      #   rescue ArgumentError
+      #     # noop
+      #   rescue
+      #     raise
+      #   end
+      #
+      #   # good (not the latest rescue)
+      #   def foo
+      #     do_something
+      #   rescue ArgumentError
+      #     raise
+      #   rescue
+      #     # noop
+      #   end
+      #
+      class UselessRescue < Base
+        MSG = 'Useless `rescue` detected.'
+
+        def on_rescue(node)
+          resbody_node = node.resbody_branches.last
+          add_offense(resbody_node) if only_reraising?(resbody_node)
+        end
+
+        private
+
+        def only_reraising?(resbody_node)
+          return false if use_exception_variable_in_ensure?(resbody_node)
+
+          body = resbody_node.body
+          return false if body.nil? || !body.send_type? || !body.method?(:raise)
+          return true unless body.arguments?
+          return false if body.arguments.size > 1
+
+          exception_name = body.first_argument.source
+
+          exception_objects(resbody_node).include?(exception_name)
+        end
+
+        def use_exception_variable_in_ensure?(resbody_node)
+          return false unless (exception_variable = resbody_node.exception_variable)
+          return false unless (ensure_node = resbody_node.each_ancestor(:ensure).first)
+          return false unless (ensure_body = ensure_node.body)
+
+          ensure_body.each_descendant(:lvar).map(&:source).include?(exception_variable.source)
+        end
+
+        def exception_objects(resbody_node)
+          [resbody_node.exception_variable&.source, '$!', '$ERROR_INFO']
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/useless_ruby2_keywords.rb

@@ -3,10 +3,10 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop looks for `ruby2_keywords` calls for methods that do not need it.
+      # Looks for `ruby2_keywords` calls for methods that do not need it.
       #
       # `ruby2_keywords` should only be called on methods that accept an argument splat
-      # (`*args`) but do not explicit keyword arguments (`k:` or `k: true`) or
+      # (`\*args`) but do not explicit keyword arguments (`k:` or `k: true`) or
       # a keyword splat (`**kwargs`).
       #
       # @example
@@ -77,10 +77,12 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          if node.first_argument.def_type?
-            inspect_def(node, node.first_argument)
+          return unless (first_argument = node.first_argument)
+
+          if first_argument.def_type?
+            inspect_def(node, first_argument)
           elsif node.first_argument.sym_type?
-            inspect_sym(node, node.first_argument)
+            inspect_sym(node, first_argument)
           end
         end
 
@@ -96,7 +98,7 @@ module RuboCop
           return unless node.parent
 
           method_name = sym_node.value
-          definition = node.parent.each_child_node.detect { |n| method_definition(n, method_name) }
+          definition = find_method_definition(node, method_name)
 
           return unless definition
           return if allowed_arguments(definition.arguments)
@@ -104,6 +106,14 @@ module RuboCop
           add_offense(node, message: format(MSG, method_name: method_name))
         end
 
+        def find_method_definition(node, method_name)
+          node.each_ancestor.lazy.map do |ancestor|
+            ancestor.each_child_node(:def, :block, :numblock).find do |child|
+              method_definition(child, method_name)
+            end
+          end.find(&:itself)
+        end
+
         # `ruby2_keywords` is only allowed if there's a `restarg` and no keyword arguments
         def allowed_arguments(arguments)
           return false if arguments.empty?

data/lib/rubocop/cop/lint/useless_setter_call.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for setter call to local variable as the final
+      # Checks for setter call to local variable as the final
       # expression of a function definition.
       #
       # @safety
@@ -11,7 +11,7 @@ module RuboCop
       #   value that is also accessible outside the local scope. This is not
       #   detected by the cop, and it can yield a false positive.
       #
-      #   As well, auto-correction is unsafe because the method's
+      #   As well, autocorrection is unsafe because the method's
       #   return value will be changed.
       #
       # @example

data/lib/rubocop/cop/lint/useless_times.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for uses of `Integer#times` that will never yield
+      # Checks for uses of `Integer#times` that will never yield
       # (when the integer <= 0) or that will only ever yield once
       # (`1.times`).
       #

data/lib/rubocop/cop/lint/void.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for operators, variables, literals, and nonmutating
+      # Checks for operators, variables, literals, lambda, proc and nonmutating
       # methods used in void context.
       #
       # @example CheckForMethodsWithNoSideEffects: false (default)
@@ -45,20 +45,24 @@ module RuboCop
         VAR_MSG = 'Variable `%<var>s` used in void context.'
         LIT_MSG = 'Literal `%<lit>s` used in void context.'
         SELF_MSG = '`self` used in void context.'
-        DEFINED_MSG = '`%<defined>s` used in void context.'
-        NONMUTATING_MSG = 'Method `#%<method>s` used in void context. Did you mean `#%<method>s!`?'
+        EXPRESSION_MSG = '`%<expression>s` used in void context.'
+        NONMUTATING_MSG = 'Method `#%<method>s` used in void context. Did you mean `#%<suggest>s`?'
 
         BINARY_OPERATORS = %i[* / % + - == === != < > <= >= <=>].freeze
         UNARY_OPERATORS = %i[+@ -@ ~ !].freeze
         OPERATORS = (BINARY_OPERATORS + UNARY_OPERATORS).freeze
         VOID_CONTEXT_TYPES = %i[def for block].freeze
-        NONMUTATING_METHODS = %i[capitalize chomp chop collect compact
-                                 delete_prefix delete_suffix downcase
-                                 encode flatten gsub lstrip map merge next
-                                 reject reverse rotate rstrip scrub select
-                                 shuffle slice sort sort_by squeeze strip sub
-                                 succ swapcase tr tr_s transform_values
-                                 unicode_normalize uniq upcase].freeze
+        NONMUTATING_METHODS_WITH_BANG_VERSION = %i[capitalize chomp chop compact
+                                                   delete_prefix delete_suffix downcase
+                                                   encode flatten gsub lstrip merge next
+                                                   reject reverse rotate rstrip scrub select
+                                                   shuffle slice sort sort_by squeeze strip sub
+                                                   succ swapcase tr tr_s transform_values
+                                                   unicode_normalize uniq upcase].freeze
+        METHODS_REPLACABLE_BY_EACH = %i[collect map].freeze
+
+        NONMUTATING_METHODS = (NONMUTATING_METHODS_WITH_BANG_VERSION +
+                               METHODS_REPLACABLE_BY_EACH).freeze
 
         def on_block(node)
           return unless node.body && !node.body.begin_type?
@@ -67,6 +71,8 @@ module RuboCop
           check_expression(node.body)
         end
 
+        alias on_numblock on_block
+
         def on_begin(node)
           check_begin(node)
         end
@@ -85,7 +91,7 @@ module RuboCop
           check_literal(expr)
           check_var(expr)
           check_self(expr)
-          check_defined(expr)
+          check_void_expression(expr)
           return unless cop_config['CheckForMethodsWithNoSideEffects']
 
           check_nonmutating(expr)
@@ -115,16 +121,21 @@ module RuboCop
           add_offense(node, message: SELF_MSG)
         end
 
-        def check_defined(node)
-          return unless node.defined_type?
+        def check_void_expression(node)
+          return unless node.defined_type? || node.lambda_or_proc?
 
-          add_offense(node, message: format(DEFINED_MSG, defined: node.source))
+          add_offense(node, message: format(EXPRESSION_MSG, expression: node.source))
         end
 
         def check_nonmutating(node)
-          return unless node.send_type? && NONMUTATING_METHODS.include?(node.method_name)
+          return unless node.respond_to?(:method_name)
+
+          method_name = node.method_name
+          return unless NONMUTATING_METHODS.include?(method_name)
 
-          add_offense(node, message: format(NONMUTATING_MSG, method: node.method_name))
+          suggestion = METHODS_REPLACABLE_BY_EACH.include?(method_name) ? 'each' : "#{method_name}!"
+          add_offense(node,
+                      message: format(NONMUTATING_MSG, method: method_name, suggest: suggestion))
         end
 
         def in_void_context?(node)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Metrics
-      # This cop checks that the ABC size of methods is not higher than the
+      # Checks that the ABC size of methods is not higher than the
       # configured maximum. The ABC size is based on assignments, branches
       # (method calls), and conditions. See http://c2.com/cgi/wiki?AbcMetric
       # and https://en.wikipedia.org/wiki/ABC_Software_Metric.
@@ -20,7 +20,7 @@ module RuboCop
       #
       # @example CountRepeatedAttributes: false (default is true)
       #
-      #    # `model` and `current_user`, refenced 3 times each,
+      #    # `model` and `current_user`, referenced 3 times each,
       #    # are each counted as only 1 branch each if
       #    # `CountRepeatedAttributes` is set to 'false'
       #
@@ -33,7 +33,9 @@ module RuboCop
       #      render 'pages/search/page'
       #    end
       #
-      # This cop also takes into account `IgnoredMethods` (defaults to `[]`)
+      # This cop also takes into account `AllowedMethods` (defaults to `[]`)
+      # And `AllowedPatterns` (defaults to `[]`)
+      #
       class AbcSize < Base
         include MethodComplexity
 

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

@@ -3,20 +3,21 @@
 module RuboCop
   module Cop
     module Metrics
-      # This cop checks if the length of a block exceeds some maximum value.
+      # Checks if the length of a block exceeds some maximum value.
       # Comment lines can optionally be ignored.
       # The maximum allowed length is configurable.
       # The cop can be configured to ignore blocks passed to certain methods.
       #
-      # You can set literals you want to fold with `CountAsOne`.
-      # Available are: 'array', 'hash', and 'heredoc'. Each literal
+      # 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.
       #
       #
       # NOTE: The `ExcludedMethods` configuration is deprecated and only kept
-      # for backwards compatibility. Please use `IgnoredMethods` instead.
+      # for backwards compatibility. Please use `AllowedMethods` and `AllowedPatterns`
+      # instead. By default, there are no methods to allowed.
       #
-      # @example CountAsOne: ['array', 'heredoc']
+      # @example CountAsOne: ['array', 'heredoc', 'method_call']
       #
       #   something do
       #     array = [         # +1
@@ -32,21 +33,25 @@ module RuboCop
       #       Heredoc
       #       content.
       #     HEREDOC
-      #   end                 # 5 points
+      #
+      #     foo(              # +1
+      #       1,
+      #       2
+      #     )
+      #   end                 # 6 points
       #
       # NOTE: This cop does not apply for `Struct` definitions.
       class BlockLength < Base
         include CodeLength
-        include IgnoredMethods
-
-        ignored_methods deprecated_key: 'ExcludedMethods'
+        include AllowedMethods
+        include AllowedPattern
 
         LABEL = 'Block'
 
         def on_block(node)
-          return if ignored_method?(node.method_name)
+          return if allowed_method?(node.method_name) || matches_allowed_pattern?(node.method_name)
           return if method_receiver_excluded?(node)
-          return if node.class_constructor? || node.struct_constructor?
+          return if node.class_constructor?
 
           check_code_length(node)
         end
@@ -58,7 +63,7 @@ module RuboCop
           node_receiver = node.receiver&.source&.gsub(/\s+/, '')
           node_method = String(node.method_name)
 
-          ignored_methods.any? do |config|
+          allowed_methods.any? do |config|
             next unless config.is_a?(String)
 
             receiver, method = config.split('.')

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Metrics
-      # This cop checks for excessive nesting of conditional and looping
+      # Checks for excessive nesting of conditional and looping
       # constructs.
       #
       # You can configure if blocks are considered using the `CountBlocks`
@@ -12,7 +12,7 @@ module RuboCop
       #
       # The maximum level of nesting allowed is configurable.
       class BlockNesting < Base
-        NESTING_BLOCKS = %i[case if while while_post until until_post for resbody].freeze
+        NESTING_BLOCKS = %i[case case_match if while while_post until until_post for resbody].freeze
 
         exclude_limit 'Max'
 

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

@@ -3,15 +3,15 @@
 module RuboCop
   module Cop
     module Metrics
-      # This cop checks if the length a class exceeds some maximum value.
+      # Checks if the length of a class exceeds some maximum value.
       # Comment lines can optionally be ignored.
       # The maximum allowed length is configurable.
       #
-      # You can set literals you want to fold with `CountAsOne`.
-      # Available are: 'array', 'hash', and 'heredoc'. Each literal
+      # 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']
+      # @example CountAsOne: ['array', 'heredoc', 'method_call']
       #
       #   class Foo
       #     ARRAY = [         # +1
@@ -27,7 +27,12 @@ module RuboCop
       #       Heredoc
       #       content.
       #     HEREDOC
-      #   end                 # 5 points
+      #
+      #     foo(              # +1
+      #       1,
+      #       2
+      #     )
+      #   end                 # 6 points
       #
       #
       # NOTE: This cop also applies for `Struct` definitions.

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Metrics
-      # This cop checks that the cyclomatic complexity of methods is not higher
+      # Checks that the cyclomatic complexity of methods is not higher
       # than the configured maximum. The cyclomatic complexity is the number of
       # linearly independent paths through a method. The algorithm counts
       # decision points and adds one.
@@ -35,7 +35,7 @@ module RuboCop
 
         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 and or or_asgn and_asgn].freeze
+                           rescue when in_pattern and or or_asgn and_asgn].freeze
 
         private
 

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

@@ -3,18 +3,20 @@
 module RuboCop
   module Cop
     module Metrics
-      # This cop checks if the length of a method exceeds some maximum value.
-      # Comment lines can optionally be ignored.
+      # Checks if the length of a method exceeds some maximum value.
+      # Comment lines can optionally be allowed.
       # The maximum allowed length is configurable.
       #
-      # You can set literals you want to fold with `CountAsOne`.
-      # Available are: 'array', 'hash', and 'heredoc'. Each literal
+      # 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.
       #
-      # NOTE: The `ExcludedMethods` configuration is deprecated and only kept
-      # for backwards compatibility. Please use `IgnoredMethods` instead.
+      # 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']
+      # @example CountAsOne: ['array', 'heredoc', 'method_call']
       #
       #   def m
       #     array = [       # +1
@@ -30,18 +32,22 @@ module RuboCop
       #       Heredoc
       #       content.
       #     HEREDOC
-      #   end               # 5 points
+      #
+      #     foo(            # +1
+      #       1,
+      #       2
+      #     )
+      #   end               # 6 points
       #
       class MethodLength < Base
         include CodeLength
-        include IgnoredMethods
-
-        ignored_methods deprecated_key: 'ExcludedMethods'
+        include AllowedMethods
+        include AllowedPattern
 
         LABEL = 'Method'
 
         def on_def(node)
-          return if ignored_method?(node.method_name)
+          return if allowed_method?(node.method_name) || matches_allowed_pattern?(node.method_name)
 
           check_code_length(node)
         end

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

@@ -3,15 +3,15 @@
 module RuboCop
   module Cop
     module Metrics
-      # This cop checks if the length a module exceeds some maximum value.
+      # Checks if the length of a module exceeds some maximum value.
       # Comment lines can optionally be ignored.
       # The maximum allowed length is configurable.
       #
-      # You can set literals you want to fold with `CountAsOne`.
-      # Available are: 'array', 'hash', and 'heredoc'. Each literal
+      # 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']
+      # @example CountAsOne: ['array', 'heredoc', 'method_call']
       #
       #   module M
       #     ARRAY = [         # +1
@@ -27,7 +27,12 @@ module RuboCop
       #       Heredoc
       #       content.
       #     HEREDOC
-      #   end                 # 5 points
+      #
+      #     foo(              # +1
+      #       1,
+      #       2
+      #     )
+      #   end                 # 6 points
       #
       class ModuleLength < Base
         include CodeLength

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

@@ -3,12 +3,26 @@
 module RuboCop
   module Cop
     module Metrics
-      # This cop checks for methods with too many parameters.
+      # Checks for methods with too many parameters.
       #
       # The maximum number of parameters is configurable.
       # Keyword arguments can optionally be excluded from the total count,
       # as they add less complexity than positional or optional parameters.
       #
+      # Any number of arguments for `initialize` method inside a block of
+      # `Struct.new` and `Data.define` like this is always allowed:
+      #
+      # [source,ruby]
+      # ----
+      # Struct.new(:one, :two, :three, :four, :five, keyword_init: true) do
+      #   def initialize(one:, two:, three:, four:, five:)
+      #   end
+      # end
+      # ----
+      #
+      # This is because checking the number of arguments of the `initialize` method
+      # does not make sense.
+      #
       # NOTE: Explicit block argument `&block` is not counted to prevent
       # erroneous change that is avoided by making block argument implicit.
       #
@@ -63,6 +77,16 @@ module RuboCop
         NAMED_KEYWORD_TYPES = %i[kwoptarg kwarg].freeze
         private_constant :NAMED_KEYWORD_TYPES
 
+        # @!method struct_new_or_data_define_block?(node)
+        def_node_matcher :struct_new_or_data_define_block?, <<~PATTERN
+          (block
+            {
+              (send (const {nil? cbase} :Struct) :new ...)
+              (send (const {nil? cbase} :Data) :define ...)
+            }
+            (args) ...)
+        PATTERN
+
         def on_def(node)
           optargs = node.arguments.select(&:optarg_type?)
           return if optargs.count <= max_optional_parameters
@@ -78,6 +102,9 @@ module RuboCop
         alias on_defs on_def
 
         def on_args(node)
+          parent = node.parent
+          return if parent.method?(:initialize) && struct_new_or_data_define_block?(parent.parent)
+
           count = args_count(node)
           return unless count > max_params
 

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Metrics
-      # This cop tries to produce a complexity score that's a measure of the
+      # Tries to produce a complexity score that's a measure of the
       # complexity the reader experiences when looking at a method. For that
       # reason it considers `when` nodes as something that doesn't add as much
       # complexity as an `if` or a `&&`. Except if it's one of those special
@@ -45,7 +45,7 @@ module RuboCop
             else
               # Otherwise, the case node gets 0.8 complexity points and each
               # when gets 0.2.
-              (0.8 + (0.2 * nb_branches)).round
+              ((nb_branches * 0.2) + 0.8).round
             end
           when :if
             node.else? && !node.elsif? ? 2 : 1

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

@@ -25,15 +25,12 @@ module RuboCop
           # > http://c2.com/cgi/wiki?AbcMetric
           CONDITION_NODES = CyclomaticComplexity::COUNTED_NODES.freeze
 
+          private_constant :BRANCH_NODES, :CONDITION_NODES
+
           def self.calculate(node, discount_repeated_attributes: false)
             new(node, discount_repeated_attributes: discount_repeated_attributes).calculate
           end
 
-          # TODO: move to rubocop-ast
-          ARGUMENT_TYPES = %i[arg optarg restarg kwarg kwoptarg kwrestarg blockarg].freeze
-
-          private_constant :BRANCH_NODES, :CONDITION_NODES, :ARGUMENT_TYPES
-
           def initialize(node)
             @assignment = 0
             @branch = 0
@@ -129,7 +126,7 @@ module RuboCop
           end
 
           def argument?(node)
-            ARGUMENT_TYPES.include?(node.type) && capturing_variable?(node.children.first)
+            node.argument_type? && capturing_variable?(node.children.first)
           end
 
           def condition?(node)

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

@@ -9,7 +9,7 @@ module RuboCop
           extend NodePattern::Macros
           include Util
 
-          FOLDABLE_TYPES = %i[array hash heredoc].freeze
+          FOLDABLE_TYPES = %i[array hash heredoc send csend].freeze
           CLASSLIKE_TYPES = %i[class module].freeze
           private_constant :FOLDABLE_TYPES, :CLASSLIKE_TYPES
 
@@ -39,7 +39,7 @@ module RuboCop
 
           private
 
-          def build_foldable_checks(types)
+          def build_foldable_checks(types) # rubocop:disable Metrics/MethodLength
             types.map do |type|
               case type
               when :array
@@ -48,15 +48,18 @@ module RuboCop
                 ->(node) { node.hash_type? }
               when :heredoc
                 ->(node) { heredoc_node?(node) }
+              when :method_call
+                ->(node) { node.call_type? }
               else
-                raise ArgumentError, "Unknown foldable type: #{type.inspect}. "\
+                raise ArgumentError, "Unknown foldable type: #{type.inspect}. " \
                                      "Valid foldable types are: #{FOLDABLE_TYPES.join(', ')}."
               end
             end
           end
 
           def normalize_foldable_types(types)
-            types.concat(%i[str dstr]) if types.delete(:heredoc)
+            types.push(:str, :dstr) if types.delete(:heredoc)
+            types.push(:send, :csend) if types.delete(:method_call)
             types
           end