rubocop 1.29.1 → 1.36.0

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

@@ -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/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 behavior 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)

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)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for `raise` or `fail` statements which are
+      # Checks for `raise` or `fail` statements which are
       # raising `Exception` class.
       #
       # You can specify a module name that will be an implicit namespace

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for `rand(1)` calls.
+      # Checks for `rand(1)` calls.
       # Such calls always return `0`.
       #
       # @example

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

@@ -6,7 +6,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop detects instances of rubocop:disable comments that can be
+      # Detects instances of rubocop:disable comments that can be
       # removed without causing any offenses to be reported. It's implemented
       # as a cop in that it inherits from the Cop base class and calls
       # add_offense. The unusual part of its implementation is that it doesn't
@@ -71,16 +71,16 @@ module RuboCop
              processed_source.comment_config.comment_only_line?(directive_comment_range.line) &&
              directive_comment_range.begin_pos == line_comment_range.begin_pos
             # When the previous line is blank, it should be retained
-            range_with_surrounding_space(range: directive_comment_range, side: :right)
+            range_with_surrounding_space(directive_comment_range, side: :right)
           else
             # Eat the entire comment, the preceding space, and the preceding
             # newline if there is one.
             original_begin = directive_comment_range.begin_pos
             range = range_with_surrounding_space(
-              range: directive_comment_range, side: :left, newlines: true
+              directive_comment_range, side: :left, newlines: true
             )
 
-            range_with_surrounding_space(range: range,
+            range_with_surrounding_space(range,
                                          side: :right,
                                          # Special for a comment that
                                          # begins the file: remove
@@ -94,13 +94,13 @@ module RuboCop
           # is NOT being removed?
           if ends_its_line?(ranges.last) && trailing_range?(ranges, range)
             # Eat the comma on the left.
-            range = range_with_surrounding_space(range: range, side: :left)
+            range = range_with_surrounding_space(range, side: :left)
             range = range_with_surrounding_comma(range, :left)
           end
 
           range = range_with_surrounding_comma(range, :right)
           # Eat following spaces up to EOL, but not the newline itself.
-          range_with_surrounding_space(range: range, side: :right, newlines: false)
+          range_with_surrounding_space(range, side: :right, newlines: false)
         end
 
         def each_redundant_disable(&block)

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

@@ -9,7 +9,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop detects instances of rubocop:enable comments that can be
+      # Detects instances of rubocop:enable comments that can be
       # removed.
       #
       # When comment enables all cops at once `rubocop:enable all`
@@ -60,7 +60,7 @@ module RuboCop
               message: format(MSG, cop: all_or_name(name))
             ) do |corrector|
               if directive.match?(cop_names)
-                corrector.remove(range_with_surrounding_space(range: directive.range, side: :right))
+                corrector.remove(range_with_surrounding_space(directive.range, side: :right))
               else
                 corrector.remove(range_with_comma(comment, name))
               end

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

@@ -24,6 +24,9 @@ module RuboCop
       class RedundantRequireStatement < Base
         include RangeHelp
         extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.2
 
         MSG = 'Remove unnecessary `require` statement.'
         RESTRICT_ON_SEND = %i[require].freeze
@@ -38,7 +41,7 @@ module RuboCop
           return unless unnecessary_require_statement?(node)
 
           add_offense(node) do |corrector|
-            range = range_with_surrounding_space(range: node.loc.expression, side: :right)
+            range = range_with_surrounding_space(node.loc.expression, side: :right)
 
             corrector.remove(range)
           end

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

@@ -3,17 +3,22 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for redundant safe navigation calls.
+      # Checks for redundant safe navigation calls.
       # `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?`.
       #
       # @safety
-      #   This cop is unsafe, because auto-correction can change the return type of
+      #   This cop is unsafe, because autocorrection can change the return type of
       #   the expression. An offending expression that previously could return `nil`
-      #   will be auto-corrected to never return `nil`.
+      #   will be autocorrected to never return `nil`.
       #
       # @example
       #   # bad
@@ -35,6 +40,14 @@ module RuboCop
       #   # good - without `&.` this will always return `true`
       #   foo&.respond_to?(:to_a)
       #
+      # @example AllowedMethods: [nil_safe_method]
+      #   # bad
+      #   do_something if attrs&.nil_safe_method(:[])
+      #
+      #   # good
+      #   do_something if attrs.nil_safe_method(:[])
+      #   do_something if attrs&.not_nil_safe_method(:[])
+      #
       class RedundantSafeNavigation < Base
         include AllowedMethods
         include RangeHelp

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for unneeded usages of splat expansion
+      # Checks for unneeded usages of splat expansion
       #
       # @example
       #

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for string conversion in string interpolation,
+      # Checks for string conversion in string interpolation,
       # which is redundant.
       #
       # @example

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for redundant `with_index`.
+      # Checks for redundant `with_index`.
       #
       # @example
       #   # bad
@@ -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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for redundant `with_object`.
+      # Checks for redundant `with_object`.
       #
       # @example
       #   # bad
@@ -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/refinement_import_methods.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks if `include` or `prepend` is called in `refine` block.
+      # Checks if `include` or `prepend` is called in `refine` block.
       # These methods are deprecated and should be replaced with `Refinement#import_methods`.
       #
       # It emulates deprecation warnings in Ruby 3.1.

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for regexp literals used as `match-current-line`.
+      # Checks for regexp literals used as `match-current-line`.
       # If a regexp literal is in condition, the regexp matches `$_` implicitly.
       #
       # @example
@@ -19,8 +19,8 @@ module RuboCop
       class RegexpAsCondition < Base
         extend AutoCorrector
 
-        MSG = 'Do not use regexp literal as a condition.' \
-              ' The regexp literal matches `$_` implicitly.'
+        MSG = 'Do not use regexp literal as a condition. ' \
+              'The regexp literal matches `$_` implicitly.'
 
         def on_match_current_line(node)
           add_offense(node) { |corrector| corrector.replace(node, "#{node.source} =~ $_") }

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for expressions where there is a call to a predicate
+      # Checks for expressions where there is a call to a predicate
       # method with at least one argument, where no parentheses are used around
       # the parameter list, and a boolean operator, && or ||, is used in the
       # last argument.