rubocop 1.22.0 → 1.45.1

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

@@ -3,12 +3,16 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop looks for error classes inheriting from `Exception`
-      # and its standard library subclasses, excluding subclasses of
-      # `StandardError`. It is configurable to suggest using either
-      # `RuntimeError` (default) or `StandardError` instead.
+      # Looks for error classes inheriting from `Exception`.
+      # It is configurable to suggest using either `StandardError` (default) or
+      # `RuntimeError` instead.
       #
-      # @example EnforcedStyle: runtime_error (default)
+      # @safety
+      #   This cop's autocorrection is unsafe because `rescue` that omit
+      #   exception class handle `StandardError` and its subclasses,
+      #   but not `Exception` and its subclasses.
+      #
+      # @example EnforcedStyle: standard_error (default)
       #   # bad
       #
       #   class C < Exception; end
@@ -17,11 +21,11 @@ module RuboCop
       #
       #   # good
       #
-      #   class C < RuntimeError; end
+      #   class C < StandardError; end
       #
-      #   C = Class.new(RuntimeError)
+      #   C = Class.new(StandardError)
       #
-      # @example EnforcedStyle: standard_error
+      # @example EnforcedStyle: runtime_error
       #   # bad
       #
       #   class C < Exception; end
@@ -30,31 +34,18 @@ module RuboCop
       #
       #   # good
       #
-      #   class C < StandardError; end
+      #   class C < RuntimeError; end
       #
-      #   C = Class.new(StandardError)
+      #   C = Class.new(RuntimeError)
       class InheritException < Base
         include ConfigurableEnforcedStyle
         extend AutoCorrector
 
-        MSG = 'Inherit from `%<prefer>s` instead of `%<current>s`.'
+        MSG = 'Inherit from `%<prefer>s` instead of `Exception`.'
         PREFERRED_BASE_CLASS = {
           runtime_error: 'RuntimeError',
           standard_error: 'StandardError'
         }.freeze
-        ILLEGAL_CLASSES = %w[
-          Exception
-          SystemStackError
-          NoMemoryError
-          SecurityError
-          NotImplementedError
-          LoadError
-          SyntaxError
-          ScriptError
-          Interrupt
-          SignalException
-          SystemExit
-        ].freeze
 
         RESTRICT_ON_SEND = %i[new].freeze
 
@@ -66,7 +57,7 @@ module RuboCop
         PATTERN
 
         def on_class(node)
-          return unless node.parent_class && illegal_class_name?(node.parent_class)
+          return unless node.parent_class && exception_class?(node.parent_class)
 
           message = message(node.parent_class)
 
@@ -77,7 +68,7 @@ module RuboCop
 
         def on_send(node)
           constant = class_new_call?(node)
-          return unless constant && illegal_class_name?(constant)
+          return unless constant && exception_class?(constant)
 
           message = message(constant)
 
@@ -92,8 +83,8 @@ module RuboCop
           format(MSG, prefer: preferred_base_class, current: node.const_name)
         end
 
-        def illegal_class_name?(class_node)
-          ILLEGAL_CLASSES.include?(class_node.const_name)
+        def exception_class?(class_node)
+          class_node.const_name == 'Exception'
         end
 
         def preferred_base_class

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

@@ -3,12 +3,13 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for interpolation in a single quoted string.
+      # Checks for interpolation in a single quoted string.
       #
       # @safety
-      #   This cop is generally safe, but is marked as unsafe because
-      #   it is possible to actually intentionally have text inside
-      #   `#{...}` in a single quoted string.
+      #   This cop's autocorrection is unsafe because although it always replaces single quotes as
+      #   if it were miswritten double quotes, it is not always the case. For example,
+      #   `'#{foo} bar'` would be replaced by `"#{foo} bar"`, so the replaced code would evaluate
+      #   the expression `foo`.
       #
       # @example
       #
@@ -24,7 +25,7 @@ module RuboCop
       class InterpolationCheck < Base
         extend AutoCorrector
 
-        MSG = 'Interpolation in single quoted string detected. '\
+        MSG = 'Interpolation in single quoted string detected. ' \
               'Use double quoted strings if you need interpolation.'
 
         def on_str(node)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks uses of lambda without a literal block.
+      # Checks uses of lambda without a literal block.
       # It emulates the following warning in Ruby 3.0:
       #
       #   % ruby -vwe 'lambda(&proc {})'
@@ -12,7 +12,7 @@ module RuboCop
       #   lambda instead
       #
       # This way, proc object is never converted to lambda.
-      # Auto-correction replaces with compatible proc argument.
+      # Autocorrection replaces with compatible proc argument.
       #
       # @example
       #
@@ -31,8 +31,15 @@ module RuboCop
         MSG = 'lambda without a literal block is deprecated; use the proc without lambda instead.'
         RESTRICT_ON_SEND = %i[lambda].freeze
 
+        # @!method lambda_with_symbol_proc?(node)
+        def_node_matcher :lambda_with_symbol_proc?, <<~PATTERN
+          (send nil? :lambda (block_pass (sym _)))
+        PATTERN
+
         def on_send(node)
-          return if node.parent&.block_type? || !node.first_argument
+          if node.parent&.block_type? || !node.first_argument || lambda_with_symbol_proc?(node)
+            return
+          end
 
           add_offense(node) do |corrector|
             corrector.replace(node, node.first_argument.source.delete('&'))

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

@@ -3,10 +3,13 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for literals used as the conditions or as
+      # Checks for literals used as the conditions or as
       # operands in and/or expressions serving as the conditions of
       # if/while/until/case-when/case-in.
       #
+      # NOTE: Literals in `case-in` condition where the match variable is used in
+      # `in` are accepted as a pattern matching.
+      #
       # @example
       #
       #   # bad
@@ -69,6 +72,8 @@ module RuboCop
 
         def on_case_match(case_match_node)
           if case_match_node.condition
+            return if case_match_node.descendants.any?(&:match_var_type?)
+
             check_case(case_match_node)
           else
             case_match_node.each_in_pattern do |in_pattern_node|

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for interpolated literals.
+      # Checks for interpolated literals.
       #
       # @example
       #
@@ -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/loop.rb

@@ -3,10 +3,10 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for uses of `begin...end while/until something`.
+      # Checks for uses of `begin...end while/until something`.
       #
       # @safety
-      #   The cop is unsafe because behaviour can change in some cases, including
+      #   The cop is unsafe because behavior can change in some cases, including
       #   if a local variable inside the loop body is accessed outside of it, or if the
       #   loop body raises a `StopIteration` exception (which `Kernel#loop` rescues).
       #

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

@@ -4,7 +4,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks that there is an `# rubocop:enable ...` statement
+      # Checks that there is an `# rubocop:enable ...` statement
       # after a `# rubocop:disable ...` statement. This will prevent leaving
       # cop disables on wide ranges of code, that latter contributors to
       # a file wouldn't be aware of.
@@ -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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for the presence of constructors and lifecycle callbacks
+      # Checks for the presence of constructors and lifecycle callbacks
       # without calls to `super`.
       #
       # This cop does not consider `method_missing` (and `respond_to_missing?`)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for nested method definitions.
+      # Checks for nested method definitions.
       #
       # @example
       #
@@ -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,7 +120,13 @@ module RuboCop
 
         def scoping_method_call?(child)
           child.sclass_type? || eval_call?(child) || exec_call?(child) ||
-            class_or_module_or_struct_new_call?(child)
+            class_constructor?(child) || 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)
@@ -90,9 +139,12 @@ module RuboCop
           (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 ...) ...)
+        # @!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
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for nested percent literals.
+      # Checks for nested percent literals.
       #
       # @example
       #

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

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for non-atomic file operation.
+      # And then replace it with a nearly equivalent and atomic method.
+      #
+      # These can cause problems that are difficult to reproduce,
+      # especially in cases of frequent file operations in parallel,
+      # such as test runs with parallel_rspec.
+      #
+      # For examples: creating a directory if there is none, has the following problems
+      #
+      # An exception occurs when the directory didn't exist at the time of `exist?`,
+      # but someone else created it before `mkdir` was executed.
+      #
+      # Subsequent processes are executed without the directory that should be there
+      # when the directory existed at the time of `exist?`,
+      # but someone else deleted it shortly afterwards.
+      #
+      # @safety
+      #   This cop is unsafe, because autocorrection change to atomic processing.
+      #   The atomic processing of the replacement destination is not guaranteed
+      #   to be strictly equivalent to that before the replacement.
+      #
+      # @example
+      #   # bad - race condition with another process may result in an error in `mkdir`
+      #   unless Dir.exist?(path)
+      #     FileUtils.mkdir(path)
+      #   end
+      #
+      #   # 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 - atomic and idempotent removal
+      #   FileUtils.rm_f(path)
+      #
+      class NonAtomicFileOperation < Base
+        extend AutoCorrector
+        include Alignment
+
+        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 remove_dir remove_entry remove_entry_secure
+                            delete unlink remove_file rm rmdir safe_unlink].freeze
+        RESTRICT_ON_SEND = (MAKE_METHODS + MAKE_FORCE_METHODS + REMOVE_METHODS +
+          REMOVE_FORCE_METHODS).freeze
+
+        # @!method send_exist_node(node)
+        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
+          (send (const nil? $_) $_ ...)
+        PATTERN
+
+        # @!method force?(node)
+        def_node_search :force?, <<~PATTERN
+          (pair (sym :force) (:true))
+        PATTERN
+
+        # @!method explicit_not_force?(node)
+        def_node_search :explicit_not_force?, <<~PATTERN
+          (pair (sym :force) (:false))
+        PATTERN
+
+        def on_send(node)
+          return unless if_node_child?(node)
+          return if explicit_not_force?(node)
+          return unless (exist_node = send_exist_node(node.parent).first)
+          return unless exist_node.first_argument == node.first_argument
+
+          register_offense(node, exist_node)
+        end
+
+        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)
+          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_remove_file_exist_check(exist_node)) do |corrector|
+            autocorrect(corrector, node, range) unless 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)
+        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))
+        end
+
+        def replacement_method(node)
+          if MAKE_METHODS.include?(node.method_name)
+            'mkdir_p'
+          elsif REMOVE_METHODS.include?(node.method_name)
+            'rm_f'
+          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
+end

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

@@ -18,7 +18,7 @@ module RuboCop
       #
       # @safety
       #   This cop is unsafe in the case where sorting files changes existing
-      #   expected behaviour.
+      #   expected behavior.
       #
       # @example
       #
@@ -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)
@@ -143,19 +155,19 @@ module RuboCop
 
         # @!method method_require?(node)
         def_node_matcher :method_require?, <<~PATTERN
-          (block-pass (send nil? :method (sym :require)))
+          (block-pass (send nil? :method (sym {:require :require_relative})))
         PATTERN
 
         # @!method unsorted_dir_glob_pass?(node)
         def_node_matcher :unsorted_dir_glob_pass?, <<~PATTERN
           (send (const {nil? cbase} :Dir) :glob ...
-            (block-pass (send nil? :method (sym :require))))
+            (block-pass (send nil? :method (sym {:require :require_relative}))))
         PATTERN
 
         # @!method unsorted_dir_each_pass?(node)
         def_node_matcher :unsorted_dir_each_pass?, <<~PATTERN
           (send (send (const {nil? cbase} :Dir) {:[] :glob} ...) :each
-            (block-pass (send nil? :method (sym :require))))
+            (block-pass (send nil? :method (sym {:require :require_relative}))))
         PATTERN
 
         # @!method loop_variable(node)
@@ -165,7 +177,7 @@ module RuboCop
 
         # @!method var_is_required?(node, name)
         def_node_search :var_is_required?, <<~PATTERN
-          (send nil? :require (lvar %1))
+          (send nil? {:require :require_relative} (lvar %1))
         PATTERN
       end
     end