rubocop 1.26.0 → 1.36.0

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

@@ -6,6 +6,15 @@ module RuboCop
       #
       # This cop checks for `IO.select` that is incompatible with Fiber Scheduler since Ruby 3.0.
       #
+      # NOTE: When the method is successful the return value of `IO.select` is `[[IO]]`,
+      # and the return value of `io.wait_readable` and `io.wait_writable` are `self`.
+      # They are not autocorrected when assigning a return value because these types are different.
+      # It's up to user how to handle the return value.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because `NoMethodError` occurs
+      #   if `require 'io/wait'` is not called.
+      #
       # @example
       #
       #   # bad
@@ -20,10 +29,6 @@ module RuboCop
       #   # good
       #   io.wait_writable(timeout)
       #
-      # @safety
-      #   This cop's autocorrection is unsafe because `NoMethodError` occurs
-      #   if `require 'io/wait'` is not called.
-      #
       class IncompatibleIoSelectWithFiberScheduler < Base
         extend AutoCorrector
 
@@ -45,6 +50,8 @@ module RuboCop
           message = format(MSG, preferred: preferred, current: node.source)
 
           add_offense(node, message: message) do |corrector|
+            next if node.parent&.assignment?
+
             corrector.replace(node, preferred)
           end
         end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for `private` or `protected` access modifiers which are
+      # Checks for `private` or `protected` access modifiers which are
       # applied to a singleton method. These access modifiers do not make
       # singleton methods private/protected. `private_class_method` can be
       # used for that.

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop looks for error classes inheriting from `Exception`.
+      # Looks for error classes inheriting from `Exception`.
       # It is configurable to suggest using either `StandardError` (default) or
       # `RuntimeError` instead.
       #

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

@@ -3,7 +3,7 @@
 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
@@ -24,7 +24,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.

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/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
       #

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,157 @@
+# 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
+        include RangeHelp
+
+        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)
+
+          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) 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)
+        end
+
+        def autocorrect(corrector, node, range)
+          corrector.remove(range)
+          autocorrect_replace_method(corrector, node)
+          corrector.remove(node.parent.loc.end) if node.parent.multiline?
+        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

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for non-local exits from iterators without a return
+      # Checks for non-local exits from iterators without a return
       # value. It registers an offense under these conditions:
       #
       # * No value is returned,

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop warns the usage of unsafe number conversions. Unsafe
+      # Warns the usage of unsafe number conversions. Unsafe
       # number conversion can cause unexpected error if auto type conversion
       # fails. Cop prefer parsing with number class instead.
       #
@@ -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,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)",
@@ -64,9 +81,9 @@ module RuboCop
           to_c: "#{Complex.name}(%<number_object>s)",
           to_r: "#{Rational.name}(%<number_object>s)"
         }.freeze
-        MSG = 'Replace unsafe number conversion with number '\
-              'class parsing, instead of using '\
-              '`%<current>s`, use stricter '\
+        MSG = 'Replace unsafe number conversion with number ' \
+              'class parsing, instead of using ' \
+              '`%<current>s`, use stricter ' \
               '`%<corrected_method>s`.'
         CONVERSION_METHODS = %i[Integer Float Complex Rational to_i to_f to_c to_r].freeze
         METHODS = CONVERSION_METHOD_CLASS_MAPPING.keys.map(&:inspect).join(' ')
@@ -91,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,
@@ -135,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)
@@ -146,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/numbered_parameter_assignment.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for uses of numbered parameter assignment.
+      # Checks for uses of numbered parameter assignment.
       # It emulates the following warning in Ruby 2.7:
       #
       #   % ruby -ve '_1 = :value'

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for unintended or-assignment to a constant.
+      # Checks for unintended or-assignment to a constant.
       #
       # Constants should always be assigned in the same location. And its value
       # should always be the same. If constants are assigned in multiple
@@ -11,8 +11,7 @@ module RuboCop
       #
       # @safety
       #   This cop is unsafe because code that is already conditionally
-      #   assigning a constant may have its behaviour changed by
-      #   auto-correction.
+      #   assigning a constant may have its behavior changed by autocorrection.
       #
       # @example
       #

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

@@ -55,7 +55,7 @@ module RuboCop
 
         def chained_calls?(node)
           first_argument = node.first_argument
-          first_argument.send_type? && (node.children.last&.children&.count || 0) > 1
+          first_argument.call_type? && (node.children.last&.children&.count || 0) > 1
         end
 
         def ternary_expression?(node)
@@ -69,7 +69,7 @@ module RuboCop
                             else
                               0
                             end
-          without_receiver = node.source[receiver_length..-1]
+          without_receiver = node.source[receiver_length..]
 
           # Escape question mark if any.
           method_regexp = Regexp.escape(node.method_name)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for quotes and commas in %w, e.g. `%w('foo', "bar")`
+      # Checks for quotes and commas in %w, e.g. `%w('foo', "bar")`
       #
       # It is more likely that the additional characters are unintended (for
       # example, mistranslating an array of literals to percent string notation)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for colons and commas in %i, e.g. `%i(:foo, :bar)`
+      # Checks for colons and commas in %i, e.g. `%i(:foo, :bar)`
       #
       # It is more likely that the additional characters are unintended (for
       # example, mistranslating an array of literals to percent string notation)