rubocop 1.32.0 → 1.35.1

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

@@ -15,9 +15,19 @@ module RuboCop
       # [source,yaml]
       # ----
       # Lint/Debugger:
-      #   WebConsole: ~
+      #   DebuggerMethods:
+      #     WebConsole: ~
       # ----
       #
+      # You can also add your own methods by adding a new category:
+      #
+      # [source,yaml]
+      # ----
+      # Lint/Debugger:
+      #   DebuggerMethods:
+      #     MyDebugger:
+      #       MyDebugger.debug_this
+      # ----
       #
       # @example
       #
@@ -57,19 +67,6 @@ module RuboCop
       class Debugger < Base
         MSG = 'Remove debugger entry point `%<source>s`.'
 
-        # @!method kernel?(node)
-        def_node_matcher :kernel?, <<~PATTERN
-          (const {nil? cbase} :Kernel)
-        PATTERN
-
-        # @!method valid_receiver?(node, arg1)
-        def_node_matcher :valid_receiver?, <<~PATTERN
-          {
-            (const {nil? cbase} %1)
-            (send {nil? #kernel?} %1)
-          }
-        PATTERN
-
         def on_send(node)
           return unless debugger_method?(node)
 
@@ -91,7 +88,7 @@ module RuboCop
 
               *receiver, method_name = v.split('.')
               {
-                receiver: receiver.empty? ? nil : receiver.join.to_sym,
+                receiver: receiver.empty? ? nil : receiver.map(&:to_sym),
                 method_name: method_name.to_sym
               }
             end.compact
@@ -105,10 +102,23 @@ module RuboCop
             if method[:receiver].nil?
               send_node.receiver.nil?
             else
-              valid_receiver?(send_node.receiver, method[:receiver])
+              method[:receiver] == receiver_chain(send_node)
             end
           end
         end
+
+        def receiver_chain(send_node)
+          receivers = []
+          receiver = send_node.receiver
+
+          while receiver
+            name = receiver.send_type? ? receiver.method_name : receiver.const_name&.to_sym
+            receivers.unshift(name)
+            receiver = receiver.receiver
+          end
+
+          receivers
+        end
       end
     end
   end

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

@@ -66,7 +66,7 @@ module RuboCop
           private
 
           def delimiter
-            CLASS_METHOD_DELIMETER
+            CLASS_METHOD_DELIMITER
           end
         end
 
@@ -89,7 +89,7 @@ module RuboCop
           private
 
           def delimiter
-            instance_method? ? INSTANCE_METHOD_DELIMETER : CLASS_METHOD_DELIMETER
+            instance_method? ? INSTANCE_METHOD_DELIMITER : CLASS_METHOD_DELIMITER
           end
 
           def instance_method?
@@ -126,8 +126,8 @@ module RuboCop
 
         RESTRICT_ON_SEND = DEPRECATED_METHODS_OBJECT.keys.map(&:method).freeze
 
-        CLASS_METHOD_DELIMETER = '.'
-        INSTANCE_METHOD_DELIMETER = '#'
+        CLASS_METHOD_DELIMITER = '.'
+        INSTANCE_METHOD_DELIMITER = '#'
 
         def on_send(node)
           check(node) do |deprecated|

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

@@ -63,7 +63,7 @@ module RuboCop
       class EmptyBlock < Base
         MSG = 'Empty block detected.'
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           return if node.body
           return if allow_empty_lambdas? && lambda_or_proc?(node)
           return if cop_config['AllowComments'] && allow_comment?(node)

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

@@ -4,6 +4,14 @@ module RuboCop
   module Cop
     module Lint
       # Checks for the presence of `if`, `elsif` and `unless` branches without a body.
+      #
+      # NOTE: empty `else` branches are handled by `Style/EmptyElse`.
+      #
+      # @safety
+      #   Autocorrection for this cop is not safe. The conditions for empty branches that
+      #   the autocorrection removes may have side effects, or the logic in subsequent
+      #   branches may change due to the removal of a previous condition.
+      #
       # @example
       #   # bad
       #   if condition
@@ -53,7 +61,9 @@ module RuboCop
       #   end
       #
       class EmptyConditionalBody < Base
+        extend AutoCorrector
         include CommentsHelp
+        include RangeHelp
 
         MSG = 'Avoid `%<keyword>s` branches without a body.'
 
@@ -61,7 +71,61 @@ module RuboCop
           return if node.body
           return if cop_config['AllowComments'] && contains_comments?(node)
 
-          add_offense(node, message: format(MSG, keyword: node.keyword))
+          add_offense(node, message: format(MSG, keyword: node.keyword)) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          remove_comments(corrector, node)
+          remove_empty_branch(corrector, node)
+          correct_other_branches(corrector, node)
+        end
+
+        def remove_comments(corrector, node)
+          comments_in_range(node).each do |comment|
+            range = range_by_whole_lines(comment.loc.expression, include_final_newline: true)
+            corrector.remove(range)
+          end
+        end
+
+        def remove_empty_branch(corrector, node)
+          corrector.remove(deletion_range(branch_range(node)))
+        end
+
+        def correct_other_branches(corrector, node)
+          return unless (node.if? || node.unless?) && node.else_branch
+
+          if node.else_branch.if_type?
+            # Replace an orphaned `elsif` with `if`
+            corrector.replace(node.else_branch.loc.keyword, 'if')
+          else
+            # Flip orphaned `else`
+            corrector.replace(node.loc.else, "#{node.inverse_keyword} #{node.condition.source}")
+          end
+        end
+
+        def branch_range(node)
+          if node.loc.else
+            node.source_range.with(end_pos: node.loc.else.begin_pos - 1)
+          else
+            node.source_range
+          end
+        end
+
+        def deletion_range(range)
+          # Collect a range between the start of the `if` node and the next relevant node,
+          # including final new line.
+          # Based on `RangeHelp#range_by_whole_lines` but allows the `if` to not start
+          # on the first column.
+          buffer = @processed_source.buffer
+
+          last_line = buffer.source_line(range.last_line)
+          end_offset = last_line.length - range.last_column + 1
+
+          range.adjust(end_pos: end_offset).intersect(buffer.source_range)
         end
       end
     end

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

@@ -6,18 +6,18 @@ module RuboCop
       #
       # This cop emulates the following Ruby warnings in Ruby 2.6.
       #
+      # [source,console]
+      # ----
       # % cat example.rb
       # ERB.new('hi', nil, '-', '@output_buffer')
       # % ruby -rerb example.rb
-      # example.rb:1: warning: Passing safe_level with the 2nd argument of
-      # ERB.new is deprecated. Do not use it, and specify other arguments as
-      # keyword arguments.
-      # example.rb:1: warning: Passing trim_mode with the 3rd argument of
-      # ERB.new is deprecated. Use keyword argument like
-      # ERB.new(str, trim_mode:...) instead.
-      # example.rb:1: warning: Passing eoutvar with the 4th argument of ERB.new
-      # is deprecated. Use keyword argument like ERB.new(str, eoutvar: ...)
-      # instead.
+      # example.rb:1: warning: Passing safe_level with the 2nd argument of ERB.new is
+      # deprecated. Do not use it, and specify other arguments as keyword arguments.
+      # example.rb:1: warning: Passing trim_mode with the 3rd argument of ERB.new is
+      # deprecated. Use keyword argument like ERB.new(str, trim_mode:...) instead.
+      # example.rb:1: warning: Passing eoutvar with the 4th argument of ERB.new is
+      # deprecated. Use keyword argument like ERB.new(str, eoutvar: ...) instead.
+      # ----
       #
       # Now non-keyword arguments other than first one are softly deprecated
       # and will be removed when Ruby 2.5 becomes EOL.

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

@@ -58,6 +58,7 @@ module RuboCop
           (node.str_type? && !node.loc.respond_to?(:begin)) || node.source_range.is?('__LINE__')
         end
 
+        # rubocop:disable Metrics/MethodLength
         def autocorrected_value(node)
           case node.type
           when :int
@@ -70,10 +71,13 @@ module RuboCop
             autocorrected_value_for_symbol(node)
           when :array
             autocorrected_value_for_array(node)
+          when :nil
+            ''
           else
             node.source.gsub('"', '\"')
           end
         end
+        # rubocop:enable Metrics/MethodLength
 
         def autocorrected_value_for_string(node)
           if node.source.start_with?("'", '%q')

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

@@ -25,13 +25,8 @@ module RuboCop
       class NextWithoutAccumulator < Base
         MSG = 'Use `next` with an accumulator argument in a `reduce`.'
 
-        # @!method on_body_of_reduce(node)
-        def_node_matcher :on_body_of_reduce, <<~PATTERN
-          (block (send _recv {:reduce :inject} !sym) _blockargs $(begin ...))
-        PATTERN
-
         def on_block(node)
-          on_body_of_reduce(node) do |body|
+          on_block_body_of_reduce(node) do |body|
             void_next = body.each_node(:next).find do |n|
               n.children.empty? && parent_block_node(n) == node
             end
@@ -40,11 +35,35 @@ module RuboCop
           end
         end
 
+        def on_numblock(node)
+          on_numblock_body_of_reduce(node) do |body|
+            void_next = body.each_node(:next).find do |n|
+              n.children.empty? && parent_numblock_node(n) == node
+            end
+
+            add_offense(void_next) if void_next
+          end
+        end
+
         private
 
+        # @!method on_block_body_of_reduce(node)
+        def_node_matcher :on_block_body_of_reduce, <<~PATTERN
+          (block (send _recv {:reduce :inject} !sym) _blockargs $(begin ...))
+        PATTERN
+
+        # @!method on_numblock_body_of_reduce(node)
+        def_node_matcher :on_numblock_body_of_reduce, <<~PATTERN
+          (numblock (send _recv {:reduce :inject} !sym) _argscount $(begin ...))
+        PATTERN
+
         def parent_block_node(node)
           node.each_ancestor(:block).first
         end
+
+        def parent_numblock_node(node)
+          node.each_ancestor(:numblock).first
+        end
       end
     end
   end

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

@@ -99,19 +99,19 @@ module RuboCop
         end
 
         def register_offense(node, exist_node)
-          unless force_method?(node)
-            add_offense(node,
-                        message: format(MSG_CHANGE_FORCE_METHOD,
-                                        method_name: replacement_method(node)))
-          end
+          add_offense(node, message: message_change_force_method(node)) unless force_method?(node)
 
           range = range_between(node.parent.loc.keyword.begin_pos,
                                 exist_node.loc.expression.end_pos)
           add_offense(range, message: message_remove_file_exist_check(exist_node)) do |corrector|
-            autocorrect(corrector, node, range)
+            autocorrect(corrector, node, range) unless node.parent.elsif?
           end
         end
 
+        def message_change_force_method(node)
+          format(MSG_CHANGE_FORCE_METHOD, method_name: replacement_method(node))
+        end
+
         def message_remove_file_exist_check(node)
           receiver, method_name = receiver_and_method_name(node)
           format(MSG_REMOVE_FILE_EXIST_CHECK, receiver: receiver, method_name: method_name)

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

@@ -74,6 +74,18 @@ module RuboCop
           end
         end
 
+        def on_numblock(node)
+          return if target_ruby_version >= 3.0
+          return unless node.body
+          return unless unsorted_dir_loop?(node.send_node)
+
+          node.argument_list
+              .filter { |argument| var_is_required?(node.body, argument.name) }
+              .each do
+                add_offense(node.send_node) { |corrector| correct_block(corrector, node.send_node) }
+              end
+        end
+
         def on_block_pass(node)
           return if target_ruby_version >= 3.0
           return unless method_require?(node)

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

@@ -16,8 +16,8 @@ module RuboCop
       # NOTE: Some values cannot be converted properly using one of the `Kernel`
       # method (for instance, `Time` and `DateTime` values are allowed by this
       # cop by default). Similarly, Rails' duration methods do not work well
-      # with `Integer()` and can be ignored with `IgnoredMethods`. By default,
-      # there are no methods to ignored.
+      # with `Integer()` and can be allowed with `AllowedMethods`. By default,
+      # there are no methods to allowed.
       #
       # @safety
       #   Autocorrection is unsafe because it is not guaranteed that the
@@ -46,12 +46,22 @@ module RuboCop
       #   foo.try { |i| Float(i) }
       #   bar.send { |i| Complex(i) }
       #
-      # @example IgnoredMethods: [] (default)
+      # @example AllowedMethods: [] (default)
       #
       #   # bad
       #   10.minutes.to_i
       #
-      # @example IgnoredMethods: [minutes]
+      # @example AllowedMethods: [minutes]
+      #
+      #   # good
+      #   10.minutes.to_i
+      #
+      # @example AllowedPatterns: [] (default)
+      #
+      #   # bad
+      #   10.minutes.to_i
+      #
+      # @example AllowedPatterns: [/min*/]
       #
       #   # good
       #   10.minutes.to_i
@@ -62,7 +72,8 @@ module RuboCop
       #   Time.now.to_datetime.to_i
       class NumberConversion < Base
         extend AutoCorrector
-        include IgnoredMethods
+        include AllowedMethods
+        include AllowedPattern
 
         CONVERSION_METHOD_CLASS_MAPPING = {
           to_i: "#{Integer.name}(%<number_object>s, 10)",
@@ -97,7 +108,7 @@ module RuboCop
 
         def handle_conversion_method(node)
           to_method(node) do |receiver, to_method|
-            next if receiver.nil? || ignore_receiver?(receiver)
+            next if receiver.nil? || allow_receiver?(receiver)
 
             message = format(
               MSG,
@@ -141,9 +152,10 @@ module RuboCop
           corrector.remove(node.loc.end)
         end
 
-        def ignore_receiver?(receiver)
+        def allow_receiver?(receiver)
           if receiver.numeric_type? || (receiver.send_type? &&
-            (conversion_method?(receiver.method_name) || ignored_method?(receiver.method_name)))
+            (conversion_method?(receiver.method_name) ||
+            allowed_method_name?(receiver.method_name)))
             true
           elsif (receiver = top_receiver(receiver))
             receiver.const_type? && ignored_class?(receiver.const_name)
@@ -152,6 +164,10 @@ module RuboCop
           end
         end
 
+        def allowed_method_name?(name)
+          allowed_method?(name) || matches_allowed_pattern?(name)
+        end
+
         def top_receiver(node)
           receiver = node
           receiver = receiver.receiver until receiver.receiver.nil?

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

@@ -7,6 +7,11 @@ module RuboCop
       # `instance_of?`, `kind_of?`, `is_a?`, `eql?`, `respond_to?`, and `equal?` methods
       # are checked by default. These are customizable with `AllowedMethods` option.
       #
+      # The `AllowedMethods` option specifies nil-safe methods,
+      # in other words, it is a method that is allowed to skip safe navigation.
+      # Note that the `AllowedMethod` option is not an option that specifies methods
+      # for which to suppress (allow) this cop's check.
+      #
       # In the example below, the safe navigation operator (`&.`) is unnecessary
       # because `NilClass` has methods like `respond_to?` and `is_a?`.
       #
@@ -35,12 +40,13 @@ module RuboCop
       #   # good - without `&.` this will always return `true`
       #   foo&.respond_to?(:to_a)
       #
-      # @example AllowedMethods: [foo?]
+      # @example AllowedMethods: [nil_safe_method]
       #   # bad
-      #   do_something if attrs&.foo?(:[])
+      #   do_something if attrs&.nil_safe_method(:[])
       #
       #   # good
-      #   do_something if attrs&.bar?(:[])
+      #   do_something if attrs.nil_safe_method(:[])
+      #   do_something if attrs&.not_nil_safe_method(:[])
       #
       class RedundantSafeNavigation < Base
         include AllowedMethods

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

@@ -33,16 +33,6 @@ module RuboCop
         MSG_EACH_WITH_INDEX = 'Use `each` instead of `each_with_index`.'
         MSG_WITH_INDEX = 'Remove redundant `with_index`.'
 
-        # @!method redundant_with_index?(node)
-        def_node_matcher :redundant_with_index?, <<~PATTERN
-          (block
-            $(send
-              _ {:each_with_index :with_index} ...)
-            (args
-              (arg _))
-            ...)
-        PATTERN
-
         def on_block(node)
           return unless (send = redundant_with_index?(node))
 
@@ -58,8 +48,21 @@ module RuboCop
           end
         end
 
+        alias on_numblock on_block
+
         private
 
+        # @!method redundant_with_index?(node)
+        def_node_matcher :redundant_with_index?, <<~PATTERN
+          {
+            (block
+              $(send _ {:each_with_index :with_index} ...)
+              (args (arg _)) ...)
+            (numblock
+              $(send _ {:each_with_index :with_index} ...) 1 ...)
+          }
+        PATTERN
+
         def message(node)
           if node.method?(:each_with_index)
             MSG_EACH_WITH_INDEX

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

@@ -31,19 +31,8 @@ module RuboCop
         extend AutoCorrector
 
         MSG_EACH_WITH_OBJECT = 'Use `each` instead of `each_with_object`.'
-
         MSG_WITH_OBJECT = 'Remove redundant `with_object`.'
 
-        # @!method redundant_with_object?(node)
-        def_node_matcher :redundant_with_object?, <<~PATTERN
-          (block
-            $(send _ {:each_with_object :with_object}
-              _)
-            (args
-              (arg _))
-            ...)
-        PATTERN
-
         def on_block(node)
           return unless (send = redundant_with_object?(node))
 
@@ -59,8 +48,20 @@ module RuboCop
           end
         end
 
+        alias on_numblock on_block
+
         private
 
+        # @!method redundant_with_object?(node)
+        def_node_matcher :redundant_with_object?, <<~PATTERN
+          {
+            (block
+              $(send _ {:each_with_object :with_object} _) (args (arg _)) ...)
+            (numblock
+              $(send _ {:each_with_object :with_object} _) 1 ...)
+          }
+        PATTERN
+
         def message(node)
           if node.method?(:each_with_object)
             MSG_EACH_WITH_OBJECT

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

@@ -7,6 +7,14 @@ module RuboCop
       # less specific exception being rescued before a more specific
       # exception is rescued.
       #
+      # An exception is considered shadowed if it is rescued after its
+      # ancestor is, or if it and its ancestor are both rescued in the
+      # same `rescue` statement. In both cases, the more specific rescue is
+      # unnecessary because it is covered by rescuing the less specific
+      # exception. (ie. `rescue Exception, StandardError` has the same behavior
+      # whether `StandardError` is included or not, because all `StandardError`s
+      # are rescued by `rescue Exception`).
+      #
       # @example
       #
       #   # bad
@@ -19,6 +27,13 @@ module RuboCop
       #     handle_standard_error
       #   end
       #
+      #   # bad
+      #   begin
+      #     something
+      #   rescue Exception, StandardError
+      #     handle_error
+      #   end
+      #
       #   # good
       #
       #   begin

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

@@ -67,10 +67,19 @@ module RuboCop
           variable_node = variable.scope.node.parent
           return false unless variable_node.conditional?
 
-          outer_local_variable_node = outer_local_variable.scope.node
+          outer_local_variable_node =
+            find_conditional_node_from_ascendant(outer_local_variable.declaration_node)
+          return true unless outer_local_variable_node
 
           outer_local_variable_node.conditional? && variable_node == outer_local_variable_node
         end
+
+        def find_conditional_node_from_ascendant(node)
+          return unless (parent = node.parent)
+          return parent if parent.conditional?
+
+          find_conditional_node_from_ascendant(parent)
+        end
       end
     end
   end

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

@@ -101,10 +101,14 @@ 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_allowed_pattern?(send_node.source)
@@ -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/useless_access_modifier.rb

@@ -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/void.rb

@@ -67,6 +67,8 @@ module RuboCop
           check_expression(node.body)
         end
 
+        alias on_numblock on_block
+
         def on_begin(node)
           check_begin(node)
         end

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

@@ -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