rubocop 1.19.0 → 1.40.0

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for redundant access modifiers, including those with no
+      # Checks for redundant access modifiers, including those with no
       # code, those which are repeated, and leading `public` modifiers in a
       # class or module body. Conditionally-defined methods are considered as
       # always being defined, and thus access modifiers guarding such methods
@@ -31,8 +31,8 @@ module RuboCop
       #   # bad
       #   class Foo
       #     # The following is redundant (methods defined on the class'
-      #     # singleton class are not affected by the public modifier)
-      #     public
+      #     # singleton class are not affected by the private modifier)
+      #     private
       #
       #     def self.method3
       #     end
@@ -142,6 +142,8 @@ module RuboCop
           check_node(node.body)
         end
 
+        alias on_numblock on_block
+
         private
 
         def autocorrect(corrector, node)
@@ -157,17 +159,17 @@ module RuboCop
 
         # @!method dynamic_method_definition?(node)
         def_node_matcher :dynamic_method_definition?, <<~PATTERN
-          {(send nil? :define_method ...) (block (send nil? :define_method ...) ...)}
+          {(send nil? :define_method ...) ({block numblock} (send nil? :define_method ...) ...)}
         PATTERN
 
         # @!method class_or_instance_eval?(node)
         def_node_matcher :class_or_instance_eval?, <<~PATTERN
-          (block (send _ {:class_eval :instance_eval}) ...)
+          ({block numblock} (send _ {:class_eval :instance_eval}) ...)
         PATTERN
 
         # @!method class_or_module_or_struct_new_call?(node)
         def_node_matcher :class_or_module_or_struct_new_call?, <<~PATTERN
-          (block (send (const {nil? cbase} {:Class :Module :Struct}) :new ...) ...)
+          ({block numblock} (send (const {nil? cbase} {:Class :Module :Struct}) :new ...) ...)
         PATTERN
 
         def check_node(node)
@@ -277,7 +279,7 @@ module RuboCop
             matcher_name = "#{m}_block?".to_sym
             unless respond_to?(matcher_name)
               self.class.def_node_matcher matcher_name, <<~PATTERN
-                (block (send {nil? const} {:#{m}} ...) ...)
+                ({block numblock} (send {nil? const} {:#{m}} ...) ...)
               PATTERN
             end
 

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for every useless assignment to local variable in every
+      # Checks for every useless assignment to local variable in every
       # scope.
       # The basic idea for this cop was from the warning of `ruby -cw`:
       #

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

@@ -3,10 +3,9 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for useless `else` in `begin..end` without `rescue`.
+      # Checks for useless `else` in `begin..end` without `rescue`.
       #
-      # NOTE: This syntax is no longer valid on Ruby 2.6 or higher and
-      # this cop is going to be removed at some point the future.
+      # NOTE: This syntax is no longer valid on Ruby 2.6 or higher.
       #
       # @example
       #

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

@@ -3,11 +3,12 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for useless method definitions, specifically: empty constructors
+      # Checks for useless method definitions, specifically: empty constructors
       # and methods just delegating to `super`.
       #
-      # This cop is marked as unsafe as it can trigger false positives for cases when
-      # an empty constructor just overrides the parent constructor, which is bad anyway.
+      # @safety
+      #   This cop is unsafe as it can register false positives for cases when an empty
+      #   constructor just overrides the parent constructor, which is bad anyway.
       #
       # @example
       #   # bad

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # 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
+      # a keyword splat (`**kwargs`).
+      #
+      # @example
+      #   # good (splat argument without keyword arguments)
+      #   ruby2_keywords def foo(*args); end
+      #
+      #   # bad (no arguments)
+      #   ruby2_keywords def foo; end
+      #
+      #   # good
+      #   def foo; end
+      #
+      #   # bad (positional argument)
+      #   ruby2_keywords def foo(arg); end
+      #
+      #   # good
+      #   def foo(arg); end
+      #
+      #   # bad (double splatted argument)
+      #   ruby2_keywords def foo(**args); end
+      #
+      #   # good
+      #   def foo(**args); end
+      #
+      #   # bad (keyword arguments)
+      #   ruby2_keywords def foo(i:, j:); end
+      #
+      #   # good
+      #   def foo(i:, j:); end
+      #
+      #   # bad (splat argument with keyword arguments)
+      #   ruby2_keywords def foo(*args, i:, j:); end
+      #
+      #   # good
+      #   def foo(*args, i:, j:); end
+      #
+      #   # bad (splat argument with double splat)
+      #   ruby2_keywords def foo(*args, **kwargs); end
+      #
+      #   # good
+      #   def foo(*args, **kwargs); end
+      #
+      #   # bad (ruby2_keywords given a symbol)
+      #   def foo; end
+      #   ruby2_keywords :foo
+      #
+      #   # good
+      #   def foo; end
+      #
+      #   # bad (ruby2_keywords with dynamic method)
+      #   define_method(:foo) { |arg| }
+      #   ruby2_keywords :foo
+      #
+      #   # good
+      #   define_method(:foo) { |arg| }
+      #
+      class UselessRuby2Keywords < Base
+        MSG = '`ruby2_keywords` is unnecessary for method `%<method_name>s`.'
+        RESTRICT_ON_SEND = %i[ruby2_keywords].freeze
+
+        # Looks for statically or dynamically defined methods with a given name
+        # @!method method_definition(node, method_name)
+        def_node_matcher :method_definition, <<~PATTERN
+          {
+            (def %1 ...)
+            ({block numblock} (send _ :define_method (sym %1)) ...)
+          }
+        PATTERN
+
+        def on_send(node)
+          if node.first_argument.def_type?
+            inspect_def(node, node.first_argument)
+          elsif node.first_argument.sym_type?
+            inspect_sym(node, node.first_argument)
+          end
+        end
+
+        private
+
+        def inspect_def(node, def_node)
+          return if allowed_arguments(def_node.arguments)
+
+          add_offense(node.loc.selector, message: format(MSG, method_name: def_node.method_name))
+        end
+
+        def inspect_sym(node, sym_node)
+          return unless node.parent
+
+          method_name = sym_node.value
+          definition = node.parent.each_child_node.detect { |n| method_definition(n, method_name) }
+
+          return unless definition
+          return if allowed_arguments(definition.arguments)
+
+          add_offense(node, message: format(MSG, method_name: method_name))
+        end
+
+        # `ruby2_keywords` is only allowed if there's a `restarg` and no keyword arguments
+        def allowed_arguments(arguments)
+          return false if arguments.empty?
+
+          arguments.each_child_node(:restarg).any? &&
+            arguments.each_child_node(:kwarg, :kwoptarg, :kwrestarg).none?
+        end
+      end
+    end
+  end
+end

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

@@ -3,13 +3,16 @@
 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.
-      # Its auto-correction is marked as unsafe because return value will be changed.
       #
-      # NOTE: There are edge cases in which the local variable references a
-      # value that is also accessible outside the local scope. This is not
-      # detected by the cop, and it can yield a false positive.
+      # @safety
+      #   There are edge cases in which the local variable references a
+      #   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, autocorrection is unsafe because the method's
+      #   return value will be changed.
       #
       # @example
       #

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

@@ -3,12 +3,13 @@
 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`).
       #
-      # This cop is marked as unsafe as `times` returns its receiver, which
-      # is *usually* OK, but might change behavior.
+      # @safety
+      #   This cop is unsafe as `times` returns its receiver, which is
+      #   *usually* OK, but might change behavior.
       #
       # @example
       #   # bad
@@ -50,22 +51,26 @@ module RuboCop
           node = node.block_node if node.block_literal?
 
           add_offense(node, message: format(MSG, count: count)) do |corrector|
-            next unless own_line?(node)
-
-            if never_process?(count, node)
-              remove_node(corrector, node)
-            elsif !proc_name.empty?
-              autocorrect_block_pass(corrector, node, proc_name)
-            else
-              autocorrect_block(corrector, node)
-            end
+            next if !own_line?(node) || node.parent&.send_type?
+
+            autocorrect(corrector, count, node, proc_name)
           end
         end
 
         private
 
+        def autocorrect(corrector, count, node, proc_name)
+          if never_process?(count, node)
+            remove_node(corrector, node)
+          elsif !proc_name.empty?
+            autocorrect_block_pass(corrector, node, proc_name)
+          else
+            autocorrect_block(corrector, node)
+          end
+        end
+
         def never_process?(count, node)
-          count < 1 || node.block_type? && node.body.nil?
+          count < 1 || (node.block_type? && node.body.nil?)
         end
 
         def remove_node(corrector, node)
@@ -90,7 +95,7 @@ module RuboCop
           # Cleanup indentation in a multiline block
           source_lines = source.split("\n")
 
-          source_lines[1..-1].each do |line|
+          source_lines[1..].each do |line|
             next if line.empty?
 
             line[range] = ''

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,7 +45,7 @@ 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.'
+        EXPRESSION_MSG = '`%<expression>s` used in void context.'
         NONMUTATING_MSG = 'Method `#%<method>s` used in void context. Did you mean `#%<method>s!`?'
 
         BINARY_OPERATORS = %i[* / % + - == === != < > <= >= <=>].freeze
@@ -67,6 +67,8 @@ module RuboCop
           check_expression(node.body)
         end
 
+        alias on_numblock on_block
+
         def on_begin(node)
           check_begin(node)
         end
@@ -85,7 +87,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,10 +117,10 @@ 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)

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

@@ -3,18 +3,24 @@
 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.
       #
+      # Interpreting ABC size:
+      #
+      # * <= 17 satisfactory
+      # * 18..30 unsatisfactory
+      # * > 30 dangerous
+      #
       # You can have repeated "attributes" calls count as a single "branch".
       # For this purpose, attributes are any method with no argument; no attempt
       # is meant to distinguish actual `attr_reader` from other methods.
       #
       # @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'
       #
@@ -27,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,24 +33,29 @@ 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?
 
           check_code_length(node)
         end
+        alias on_numblock on_block
 
         private
 
@@ -57,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`

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 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.
@@ -46,15 +46,6 @@ module RuboCop
           1
         end
 
-        def block_method(node)
-          case node.type
-          when :block
-            node.method_name
-          when :block_pass
-            node.parent.method_name
-          end
-        end
-
         def count_block?(block)
           KNOWN_ITERATING_METHODS.include? block.method_name
         end

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
@@ -52,6 +58,7 @@ module RuboCop
 
           check_code_length(node)
         end
+        alias on_numblock on_block
 
         private
 

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 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
@@ -44,7 +49,7 @@ module RuboCop
 
         # @!method module_definition?(node)
         def_node_matcher :module_definition?, <<~PATTERN
-          (casgn nil? _ (block (send (const {nil? cbase} :Module) :new) ...))
+          (casgn nil? _ ({block numblock} (send (const {nil? cbase} :Module) :new) ...))
         PATTERN
 
         def message(length, max_length)

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

@@ -3,12 +3,15 @@
 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.
       #
+      # NOTE: Explicit block argument `&block` is not counted to prevent
+      # erroneous change that is avoided by making block argument implicit.
+      #
       # @example Max: 3
       #   # good
       #   def foo(a, b, c = 1)
@@ -94,9 +97,9 @@ module RuboCop
 
         def args_count(node)
           if count_keyword_args?
-            node.children.size
+            node.children.count { |a| !a.blockarg_type? }
           else
-            node.children.count { |a| !NAMED_KEYWORD_TYPES.include?(a.type) }
+            node.children.count { |a| !NAMED_KEYWORD_TYPES.include?(a.type) && !a.blockarg_type? }
           end
         end