rubocop 1.22.0 → 1.45.1

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

@@ -3,14 +3,13 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop repacks Parser's diagnostics/errors
+      # Repacks Parser's diagnostics/errors
       # into RuboCop's offenses.
       class Syntax < Base
         def on_other_file
           add_offense_from_error(processed_source.parser_error) if processed_source.parser_error
           processed_source.diagnostics.each do |diagnostic|
-            add_offense_from_diagnostic(diagnostic,
-                                        processed_source.ruby_version)
+            add_offense_from_diagnostic(diagnostic, processed_source.ruby_version)
           end
           super
         end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop ensures that `to_enum`/`enum_for`, called for the current method,
+      # Ensures that `to_enum`/`enum_for`, called for the current method,
       # has correct arguments.
       #
       # @example

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks to make sure `#to_json` includes an optional argument.
+      # Checks to make sure `#to_json` includes an optional argument.
       # When overriding `#to_json`, callers may invoke JSON
       # generation via `JSON.generate(your_obj)`.  Since `JSON#generate` allows
       # for an optional argument, your method should too.

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for top level return with arguments. If there is a
+      # Checks for top level return with arguments. If there is a
       # top-level return statement with an argument, then the argument is
       # always ignored. This is detected automatically since Ruby 2.7.
       #

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for trailing commas in attribute declarations, such as
+      # Checks for trailing commas in attribute declarations, such as
       # `#attr_reader`. Leaving a trailing comma will nullify the next method
       # definition by overriding it with a getter method.
       #
@@ -45,7 +45,7 @@ module RuboCop
 
         def trailing_comma_range(node)
           range_with_surrounding_space(
-            range: node.arguments[-2].source_range,
+            node.arguments[-2].source_range,
             side: :right
           ).end.resize(1)
         end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for "triple quotes" (strings delimited by any odd number
+      # Checks for "triple quotes" (strings delimited by any odd number
       # of quotes greater than 1).
       #
       # Ruby allows multiple strings to be implicitly concatenated by just

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for underscore-prefixed variables that are actually
+      # Checks for underscore-prefixed variables that are actually
       # used.
       #
       # Since block keyword arguments cannot be arbitrarily named at call

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for a block that is known to need more positional
+      # Checks for a block that is known to need more positional
       # block arguments than are given (by default this is configured for
       # `Enumerable` methods needing 2 arguments). Optional arguments are allowed,
       # although they don't generally make sense as the default value will

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for using Fixnum or Bignum constant.
+      # Checks for using Fixnum or Bignum constant.
       #
       # @example
       #
@@ -33,6 +33,8 @@ module RuboCop
           return unless klass
 
           add_offense(node, message: format(MSG, klass: klass)) do |corrector|
+            next if target_ruby_version <= 2.3
+
             corrector.replace(node.loc.name, 'Integer')
           end
         end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for unreachable code.
+      # Checks for unreachable code.
       # The check are based on the presence of flow of control
       # statement in non-final position in `begin` (implicit) blocks.
       #

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

@@ -3,15 +3,15 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for loops that will have at most one iteration.
+      # Checks for loops that will have at most one iteration.
       #
       # A loop that can never reach the second iteration is a possible error in the code.
       # In rare cases where only one iteration (or at most one iteration) is intended behavior,
       # the code should be refactored to use `if` conditionals.
       #
-      # NOTE: Block methods that are used with `Enumerable`s are considered to be loops.
+      # NOTE: Block methods that are used with ``Enumerable``s are considered to be loops.
       #
-      # `IgnoredPatterns` can be used to match against the block receiver in order to allow
+      # `AllowedPatterns` can be used to match against the block receiver in order to allow
       # code that would otherwise be registered as an offense (eg. `times` used not in an
       # `Enumerable` context).
       #
@@ -79,12 +79,12 @@ module RuboCop
       #   # bad
       #   2.times { raise ArgumentError }
       #
-      # @example IgnoredPatterns: [/(exactly|at_least|at_most)\(\d+\)\.times/] (default)
+      # @example AllowedPatterns: ['(exactly|at_least|at_most)\(\d+\)\.times'] (default)
       #
       #   # good
       #   exactly(2).times { raise StandardError }
       class UnreachableLoop < Base
-        include IgnoredPattern
+        include AllowedPattern
 
         MSG = 'This loop will have at most one iteration.'
         CONTINUE_KEYWORDS = %i[next redo].freeze
@@ -101,13 +101,17 @@ module RuboCop
           check(node) if loop_method?(node)
         end
 
+        def on_numblock(node)
+          check(node) if loop_method?(node)
+        end
+
         private
 
         def loop_method?(node)
-          return false unless node.block_type?
+          return false unless node.block_type? || node.numblock_type?
 
           send_node = node.send_node
-          return false if matches_ignored_pattern?(send_node.source)
+          return false if matches_allowed_pattern?(send_node.source)
 
           send_node.enumerable_method? || send_node.enumerator_method? || send_node.method?(:loop)
         end
@@ -179,6 +183,8 @@ module RuboCop
 
         def preceded_by_continue_statement?(break_statement)
           break_statement.left_siblings.any? do |sibling|
+            # Numblocks have the arguments count as a number in the AST.
+            next if sibling.is_a?(Integer)
             next if sibling.loop_keyword? || loop_method?(sibling)
 
             sibling.each_descendant(*CONTINUE_KEYWORDS).any?

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for unused block arguments.
+      # Checks for unused block arguments.
       #
       # @example
       #   # bad

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for unused method arguments.
+      # Checks for unused method arguments.
       #
       # @example
       #   # bad
@@ -64,10 +64,14 @@ module RuboCop
 
         # @!method not_implemented?(node)
         def_node_matcher :not_implemented?, <<~PATTERN
-          {(send nil? :raise (const {nil? cbase} :NotImplementedError))
+          {(send nil? :raise (const {nil? cbase} :NotImplementedError) ...)
            (send nil? :fail ...)}
         PATTERN
 
+        def self.autocorrect_incompatible_with
+          [Style::ExplicitBlockArgument]
+        end
+
         def self.joining_forces
           VariableForce
         end
@@ -96,7 +100,8 @@ module RuboCop
 
           unless variable.keyword_argument?
             message << " If it's necessary, use `_` or `_#{variable.name}` " \
-                       "as an argument name to indicate that it won't be used."
+                       "as an argument name to indicate that it won't be used. " \
+                       "If it's unnecessary, remove it."
           end
 
           scope = variable.scope

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop identifies places where `URI.escape` can be replaced by
+      # Identifies places where `URI.escape` can be replaced by
       # `CGI.escape`, `URI.encode_www_form`, or `URI.encode_www_form_component`
       # depending on your specific use case.
       # Also this cop identifies places where `URI.unescape` can be replaced by

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop identifies places where `URI.regexp` is obsolete and should
+      # Identifies places where `URI.regexp` is obsolete and should
       # not be used. Instead, use `URI::DEFAULT_PARSER.make_regexp`.
       #
       # @example

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,20 @@ 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 ...) ...)
+        # @!method class_constructor?(node)
+        def_node_matcher :class_constructor?, <<~PATTERN
+          ({block numblock} {
+            (send (const {nil? cbase} {:Class :Module :Struct}) :new ...)
+            (send (const {nil? cbase} :Data) :define ...)
+          } ...)
         PATTERN
 
         def check_node(node)
@@ -268,7 +273,7 @@ module RuboCop
 
         def eval_call?(child)
           class_or_instance_eval?(child) ||
-            class_or_module_or_struct_new_call?(child) ||
+            class_constructor?(child) ||
             any_context_creating_methods?(child)
         end
 
@@ -277,7 +282,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,7 +3,7 @@
 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`.
       #
       # @safety
@@ -41,7 +41,7 @@ module RuboCop
         MSG = 'Useless method definition detected.'
 
         def on_def(node)
-          return if optional_args?(node)
+          return if use_rest_or_optional_args?(node)
           return unless delegating?(node.body, node)
 
           add_offense(node) { |corrector| corrector.remove(node) }
@@ -50,8 +50,8 @@ module RuboCop
 
         private
 
-        def optional_args?(node)
-          node.arguments.any? { |arg| arg.optarg_type? || arg.kwoptarg_type? }
+        def use_rest_or_optional_args?(node)
+          node.arguments.any? { |arg| arg.restarg_type? || arg.optarg_type? || arg.kwoptarg_type? }
         end
 
         def delegating?(node, def_node)

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

@@ -0,0 +1,85 @@
+# 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)
+
+          ensure_node.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

@@ -0,0 +1,127 @@
+# 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)
+          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, 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 = find_method_definition(node, method_name)
+
+          return unless definition
+          return if allowed_arguments(definition.arguments)
+
+          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?
+
+          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,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`).
       #
@@ -51,20 +51,24 @@ 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?)
         end
@@ -91,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] = ''