rubocop 1.31.2 → 1.57.1

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

@@ -50,9 +50,7 @@ module RuboCop
 
         def on_new_investigation
           each_missing_enable do |cop, line_range|
-            # This has to remain a strict inequality to handle
-            # the case when max_range is Float::INFINITY
-            next if line_range.max - line_range.min < max_range + 2
+            next if acceptable_range?(cop, line_range)
 
             range = source_range(processed_source.buffer, line_range.min, (0..0))
             comment = processed_source.comment_at_line(line_range.begin)
@@ -69,6 +67,23 @@ module RuboCop
           end
         end
 
+        def acceptable_range?(cop, line_range)
+          # This has to remain a strict inequality to handle
+          # the case when max_range is Float::INFINITY
+          return true if line_range.max - line_range.min < max_range + 2
+          # This cop is disabled in the config, it is not expected to be re-enabled
+          return true if line_range.min == CommentConfig::CONFIG_DISABLED_LINE_RANGE_MIN
+
+          cop_class = RuboCop::Cop::Registry.global.find_by_cop_name cop
+          if cop_class &&
+             !processed_source.registry.enabled?(cop_class, config) &&
+             line_range.max == Float::INFINITY
+            return true
+          end
+
+          false
+        end
+
         def max_range
           @max_range ||= cop_config['MaximumRangeSize']
         end

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

@@ -11,6 +11,16 @@ module RuboCop
       # missing method. In other cases, the theoretical ideal handling could be
       # challenging or verbose for no actual gain.
       #
+      # Autocorrection is not supported because the position of `super` cannot be
+      # determined automatically.
+      #
+      # `Object` and `BasicObject` are allowed by this cop because of their
+      # stateless nature. However, sometimes you might want to allow other parent
+      # classes from this cop, for example in the case of an abstract class that is
+      # not meant to be called with `super`. In those cases, you can use the
+      # `AllowedParentClasses` option to specify which classes should be allowed
+      # *in addition to* `Object` and `BasicObject`.
+      #
       # @example
       #   # bad
       #   class Employee < Person
@@ -28,6 +38,21 @@ module RuboCop
       #   end
       #
       #   # bad
+      #   Employee = Class.new(Person) do
+      #     def initialize(name, salary)
+      #       @salary = salary
+      #     end
+      #   end
+      #
+      #   # good
+      #   Employee = Class.new(Person) do
+      #     def initialize(name, salary)
+      #       super(name)
+      #       @salary = salary
+      #     end
+      #   end
+      #
+      #   # bad
       #   class Parent
       #     def self.inherited(base)
       #       do_something
@@ -42,6 +67,21 @@ module RuboCop
       #     end
       #   end
       #
+      #   # good
+      #   class ClassWithNoParent
+      #     def initialize
+      #       do_something
+      #     end
+      #   end
+      #
+      # @example AllowedParentClasses: [MyAbstractClass]
+      #   # good
+      #   class MyConcreteClass < MyAbstractClass
+      #     def initialize
+      #       do_something
+      #     end
+      #   end
+      #
       class MissingSuper < Base
         CONSTRUCTOR_MSG = 'Call `super` to initialize state of the parent class.'
         CALLBACK_MSG    = 'Call `super` to invoke callback defined in the parent class.'
@@ -55,6 +95,13 @@ module RuboCop
 
         CALLBACKS = (CLASS_LIFECYCLE_CALLBACKS + METHOD_LIFECYCLE_CALLBACKS).to_set.freeze
 
+        # @!method class_new_block(node)
+        def_node_matcher :class_new_block, <<~RUBY
+          ({block numblock}
+            (send
+              (const {nil? cbase} :Class) :new $_) ...)
+        RUBY
+
         def on_def(node)
           return unless offender?(node)
 
@@ -78,7 +125,7 @@ module RuboCop
         end
 
         def callback_method_def?(node)
-          return unless CALLBACKS.include?(node.method_name)
+          return false unless CALLBACKS.include?(node.method_name)
 
           node.each_ancestor(:class, :sclass, :module).first
         end
@@ -88,12 +135,23 @@ module RuboCop
         end
 
         def inside_class_with_stateful_parent?(node)
-          class_node = node.each_ancestor(:class).first
-          class_node&.parent_class && !stateless_class?(class_node.parent_class)
+          if (block_node = node.each_ancestor(:block, :numblock).first)
+            return false unless (super_class = class_new_block(block_node))
+
+            !allowed_class?(super_class)
+          elsif (class_node = node.each_ancestor(:class).first)
+            class_node.parent_class && !allowed_class?(class_node.parent_class)
+          else
+            false
+          end
+        end
+
+        def allowed_class?(node)
+          allowed_classes.include?(node.const_name)
         end
 
-        def stateless_class?(node)
-          STATELESS_CLASSES.include?(node.const_name)
+        def allowed_classes
+          @allowed_classes ||= STATELESS_CLASSES + cop_config.fetch('AllowedParentClasses', [])
         end
       end
     end

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for mixed-case character ranges since they include likely unintended characters.
+      #
+      # Offenses are registered for regexp character classes like `/[A-z]/`
+      # as well as range objects like `('A'..'z')`.
+      #
+      # NOTE: Range objects cannot be autocorrected.
+      #
+      # @safety
+      #   The cop autocorrects regexp character classes
+      #   by replacing one character range with two: `A-z` becomes `A-Za-z`.
+      #   In most cases this is probably what was originally intended
+      #   but it changes the regexp to no longer match symbols it used to include.
+      #   For this reason, this cop's autocorrect is unsafe (it will
+      #   change the behavior of the code).
+      #
+      # @example
+      #
+      #   # bad
+      #   r = /[A-z]/
+      #
+      #   # good
+      #   r = /[A-Za-z]/
+      class MixedCaseRange < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Ranges from upper to lower case ASCII letters may include unintended ' \
+              'characters. Instead of `A-z` (which also includes several symbols) ' \
+              'specify each range individually: `A-Za-z` and individually specify any symbols.'
+        RANGES = [('a'..'z').freeze, ('A'..'Z').freeze].freeze
+
+        def on_irange(node)
+          return unless node.children.compact.all?(&:str_type?)
+
+          range_start, range_end = node.children
+
+          return if range_start.nil? || range_end.nil?
+
+          add_offense(node) if unsafe_range?(range_start.value, range_end.value)
+        end
+        alias on_erange on_irange
+
+        def on_regexp(node)
+          each_unsafe_regexp_range(node) do |loc|
+            add_offense(loc) do |corrector|
+              corrector.replace(loc, rewrite_regexp_range(loc.source))
+            end
+          end
+        end
+
+        def each_unsafe_regexp_range(node)
+          node.parsed_tree&.each_expression do |expr|
+            next if skip_expression?(expr)
+
+            range_pairs(expr).reject do |range_start, range_end|
+              next if skip_range?(range_start, range_end)
+
+              next unless unsafe_range?(range_start.text, range_end.text)
+
+              yield(build_source_range(range_start, range_end))
+            end
+          end
+        end
+
+        private
+
+        def build_source_range(range_start, range_end)
+          range_between(range_start.expression.begin_pos, range_end.expression.end_pos)
+        end
+
+        def range_for(char)
+          RANGES.detect do |range|
+            range.include?(char)
+          end
+        end
+
+        def range_pairs(expr)
+          RuboCop::Cop::Utils::RegexpRanges.new(expr).pairs
+        end
+
+        def unsafe_range?(range_start, range_end)
+          return false if range_start.length != 1 || range_end.length != 1
+
+          range_for(range_start) != range_for(range_end)
+        end
+
+        def skip_expression?(expr)
+          !(expr.type == :set && expr.token == :character)
+        end
+
+        def skip_range?(range_start, range_end)
+          [range_start, range_end].any? do |bound|
+            bound.type != :literal
+          end
+        end
+
+        def rewrite_regexp_range(source)
+          open, close = source.split('-')
+          first = [open, range_for(open).end]
+          second = [range_for(close).begin, close]
+          "#{first.uniq.join('-')}#{second.uniq.join('-')}"
+        end
+      end
+    end
+  end
+end

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

@@ -8,6 +8,7 @@ module RuboCop
       # Replace numbered captures with non-capturing groupings or
       # named captures.
       #
+      # @example
       #   # bad
       #   /(?<foo>FOO)(BAR)/
       #

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

@@ -30,6 +30,9 @@ module RuboCop
       #
       #   # good
       #
+      #   # `class_eval`, `instance_eval`, `module_eval`, `class_exec`, `instance_exec`, and
+      #   # `module_exec` blocks are allowed by default.
+      #
       #   def foo
       #     self.class.class_eval do
       #       def bar
@@ -54,7 +57,47 @@ module RuboCop
       #       end
       #     end
       #   end
+      #
+      # @example AllowedMethods: [] (default)
+      #   # bad
+      #   def do_something
+      #     has_many :articles do
+      #       def find_or_create_by_name(name)
+      #       end
+      #     end
+      #   end
+      #
+      # @example AllowedMethods: ['has_many']
+      #   # bad
+      #   def do_something
+      #     has_many :articles do
+      #       def find_or_create_by_name(name)
+      #       end
+      #     end
+      #   end
+      #
+      # @example AllowedPatterns: [] (default)
+      #   # bad
+      #   def foo(obj)
+      #     obj.do_baz do
+      #       def bar
+      #       end
+      #     end
+      #   end
+      #
+      # @example AllowedPatterns: ['baz']
+      #   # good
+      #   def foo(obj)
+      #     obj.do_baz do
+      #       def bar
+      #       end
+      #     end
+      #   end
+      #
       class NestedMethodDefinition < Base
+        include AllowedMethods
+        include AllowedPattern
+
         MSG = 'Method definitions must not be nested. Use `lambda` instead.'
 
         def on_def(node)
@@ -65,7 +108,7 @@ module RuboCop
           return unless def_ancestor
 
           within_scoping_def =
-            node.each_ancestor(:block, :sclass).any? do |ancestor|
+            node.each_ancestor(:block, :numblock, :sclass).any? do |ancestor|
               scoping_method_call?(ancestor)
             end
 
@@ -77,22 +120,23 @@ module RuboCop
 
         def scoping_method_call?(child)
           child.sclass_type? || eval_call?(child) || exec_call?(child) ||
-            class_or_module_or_struct_new_call?(child)
+            child.class_constructor? || allowed_method_name?(child)
+        end
+
+        def allowed_method_name?(node)
+          name = node.method_name
+
+          allowed_method?(name) || matches_allowed_pattern?(name)
         end
 
         # @!method eval_call?(node)
         def_node_matcher :eval_call?, <<~PATTERN
-          (block (send _ {:instance_eval :class_eval :module_eval} ...) ...)
+          ({block numblock} (send _ {:instance_eval :class_eval :module_eval} ...) ...)
         PATTERN
 
         # @!method exec_call?(node)
         def_node_matcher :exec_call?, <<~PATTERN
-          (block (send _ {:instance_exec :class_exec :module_exec} ...) ...)
-        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 _ {:instance_exec :class_exec :module_exec} ...) ...)
         PATTERN
       end
     end

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

@@ -25,38 +25,45 @@ module RuboCop
       #   to be strictly equivalent to that before the replacement.
       #
       # @example
-      #   # bad
-      #   unless FileTest.exist?(path)
-      #     FileUtils.makedirs(path)
+      #   # bad - race condition with another process may result in an error in `mkdir`
+      #   unless Dir.exist?(path)
+      #     FileUtils.mkdir(path)
       #   end
       #
-      #   if FileTest.exist?(path)
+      #   # good - atomic and idempotent creation
+      #   FileUtils.mkdir_p(path)
+      #
+      #   # bad - race condition with another process may result in an error in `remove`
+      #   if File.exist?(path)
       #     FileUtils.remove(path)
       #   end
       #
-      #   # good
-      #   FileUtils.mkdir_p(path)
-      #
-      #   FileUtils.rm_rf(path)
+      #   # good - atomic and idempotent removal
+      #   FileUtils.rm_f(path)
       #
       class NonAtomicFileOperation < Base
         extend AutoCorrector
-        include Alignment
-        include RangeHelp
 
-        MSG = 'Remove unnecessary existence checks `%<receiver>s.%<method_name>s`.'
-        MAKE_METHODS = %i[makedirs mkdir mkdir_p mkpath].freeze
-        REMOVE_METHODS = %i[remove remove_dir remove_entry remove_entry_secure delete unlink
-                            remove_file rm rm_f rm_r rm_rf rmdir rmtree safe_unlink].freeze
-        RESTRICT_ON_SEND = (MAKE_METHODS + REMOVE_METHODS).freeze
+        MSG_REMOVE_FILE_EXIST_CHECK = 'Remove unnecessary existence check ' \
+                                      '`%<receiver>s.%<method_name>s`.'
+        MSG_CHANGE_FORCE_METHOD = 'Use atomic file operation method `FileUtils.%<method_name>s`.'
+        MAKE_FORCE_METHODS = %i[makedirs mkdir_p mkpath].freeze
+        MAKE_METHODS = %i[mkdir].freeze
+        REMOVE_FORCE_METHODS = %i[rm_f rm_rf].freeze
+        REMOVE_METHODS = %i[remove delete unlink remove_file rm rmdir safe_unlink].freeze
+        RECURSIVE_REMOVE_METHODS = %i[remove_dir remove_entry remove_entry_secure].freeze
+        RESTRICT_ON_SEND = (
+          MAKE_METHODS + MAKE_FORCE_METHODS + REMOVE_METHODS + RECURSIVE_REMOVE_METHODS +
+          REMOVE_FORCE_METHODS
+        ).freeze
 
         # @!method send_exist_node(node)
-        def_node_search :send_exist_node, <<-PATTERN
+        def_node_search :send_exist_node, <<~PATTERN
           $(send (const nil? {:FileTest :File :Dir :Shell}) {:exist? :exists?} ...)
         PATTERN
 
         # @!method receiver_and_method_name(node)
-        def_node_matcher :receiver_and_method_name, <<-PATTERN
+        def_node_matcher :receiver_and_method_name, <<~PATTERN
           (send (const nil? $_) $_ ...)
         PATTERN
 
@@ -71,10 +78,9 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return unless (parent = node.parent) && parent.if_type?
-          return if allowable_use_with_if?(parent)
+          return unless if_node_child?(node)
           return if explicit_not_force?(node)
-          return unless (exist_node = send_exist_node(parent).first)
+          return unless (exist_node = send_exist_node(node.parent).first)
           return unless exist_node.first_argument == node.first_argument
 
           register_offense(node, exist_node)
@@ -82,44 +88,77 @@ module RuboCop
 
         private
 
+        def if_node_child?(node)
+          return false unless (parent = node.parent)
+
+          parent.if_type? && !allowable_use_with_if?(parent)
+        end
+
         def allowable_use_with_if?(if_node)
           if_node.condition.and_type? || if_node.condition.or_type? || if_node.else_branch
         end
 
         def register_offense(node, exist_node)
-          range = range_between(node.parent.loc.keyword.begin_pos,
-                                exist_node.loc.expression.end_pos)
+          add_offense(node, message: message_change_force_method(node)) unless force_method?(node)
+
+          parent = node.parent
+          range = parent.loc.keyword.begin.join(parent.condition.source_range.end)
 
-          add_offense(range, message: message(exist_node)) do |corrector|
-            autocorrect(corrector, node, range)
+          add_offense(range, message: message_remove_file_exist_check(exist_node)) do |corrector|
+            autocorrect(corrector, node, range) unless parent.elsif?
           end
         end
 
-        def message(node)
+        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, receiver: receiver, method_name: method_name)
+          format(MSG_REMOVE_FILE_EXIST_CHECK, receiver: receiver, method_name: method_name)
         end
 
         def autocorrect(corrector, node, range)
           corrector.remove(range)
+          autocorrect_replace_method(corrector, node)
+
+          if node.parent.modifier_form?
+            corrector.remove(node.source_range.end.join(node.parent.loc.keyword.begin))
+          else
+            corrector.remove(node.parent.loc.end)
+          end
+        end
+
+        def autocorrect_replace_method(corrector, node)
+          return if force_method?(node)
+
           corrector.replace(node.child_nodes.first.loc.name, 'FileUtils')
           corrector.replace(node.loc.selector, replacement_method(node))
-          corrector.remove(node.parent.loc.end) if node.parent.multiline?
         end
 
         def replacement_method(node)
-          return node.method_name if force_option?(node)
-
           if MAKE_METHODS.include?(node.method_name)
             'mkdir_p'
           elsif REMOVE_METHODS.include?(node.method_name)
+            'rm_f'
+          elsif RECURSIVE_REMOVE_METHODS.include?(node.method_name)
             'rm_rf'
+          else
+            node.method_name
           end
         end
 
+        def force_method?(node)
+          force_method_name?(node) || force_option?(node)
+        end
+
         def force_option?(node)
           node.arguments.any? { |arg| force?(arg) }
         end
+
+        def force_method_name?(node)
+          (MAKE_FORCE_METHODS + REMOVE_FORCE_METHODS).include?(node.method_name)
+        end
       end
     end
   end

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,7 +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`.
+      # 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
@@ -45,7 +46,22 @@ module RuboCop
       #   foo.try { |i| Float(i) }
       #   bar.send { |i| Complex(i) }
       #
-      # @example IgnoredMethods: [minutes]
+      # @example AllowedMethods: [] (default)
+      #
+      #   # bad
+      #   10.minutes.to_i
+      #
+      # @example AllowedMethods: [minutes]
+      #
+      #   # good
+      #   10.minutes.to_i
+      #
+      # @example AllowedPatterns: [] (default)
+      #
+      #   # bad
+      #   10.minutes.to_i
+      #
+      # @example AllowedPatterns: ['min*']
       #
       #   # good
       #   10.minutes.to_i
@@ -56,7 +72,9 @@ module RuboCop
       #   Time.now.to_datetime.to_i
       class NumberConversion < Base
         extend AutoCorrector
-        include IgnoredMethods
+        include AllowedMethods
+        include AllowedPattern
+        include IgnoredNode
 
         CONVERSION_METHOD_CLASS_MAPPING = {
           to_i: "#{Integer.name}(%<number_object>s, 10)",
@@ -91,7 +109,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,
@@ -99,7 +117,11 @@ module RuboCop
               corrected_method: correct_method(node, receiver)
             )
             add_offense(node, message: message) do |corrector|
+              next if part_of_ignored_node?(node)
+
               corrector.replace(node, correct_method(node, node.receiver))
+
+              ignore_node(node)
             end
           end
         end
@@ -135,9 +157,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)
@@ -146,6 +169,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?