rubocop 1.30.1 → 1.64.0

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

@@ -0,0 +1,165 @@
+# 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
+
+        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
+          $(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'
+          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
+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)
@@ -82,7 +94,7 @@ module RuboCop
           parent_node = node.parent
 
           add_offense(parent_node) do |corrector|
-            if parent_node.arguments.last&.block_pass_type?
+            if parent_node.last_argument&.block_pass_type?
               correct_block_pass(corrector, parent_node)
             else
               correct_block(corrector, parent_node)
@@ -104,7 +116,7 @@ module RuboCop
 
         def correct_block_pass(corrector, node)
           if unsorted_dir_glob_pass?(node)
-            block_arg = node.arguments.last
+            block_arg = node.last_argument
 
             corrector.remove(last_arg_range(node))
             corrector.insert_after(node, ".sort.each(#{block_arg.source})")
@@ -118,9 +130,7 @@ module RuboCop
         # @return [Parser::Source::Range]
         #
         def last_arg_range(node)
-          node.arguments.last.source_range.with(
-            begin_pos: node.arguments[-2].source_range.end_pos
-          )
+          node.last_argument.source_range.join(node.arguments[-2].source_range.end)
         end
 
         def unsorted_dir_loop?(node)

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

@@ -9,14 +9,15 @@ module RuboCop
       #
       # Conversion with `Integer`, `Float`, etc. will raise an `ArgumentError`
       # if given input that is not numeric (eg. an empty string), whereas
-      # `to_i`, etc. will try to convert regardless of input (`''.to_i => 0`).
+      # `to_i`, etc. will try to convert regardless of input (``''.to_i => 0``).
       # As such, this cop is disabled by default because it's not necessarily
       # always correct to raise if a value is not numeric.
       #
       # 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)",
@@ -64,34 +82,39 @@ 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(' ')
 
         # @!method to_method(node)
         def_node_matcher :to_method, <<~PATTERN
-          (send $_ ${#{METHODS}})
+          (call $_ ${#{METHODS}})
         PATTERN
 
         # @!method to_method_symbol(node)
         def_node_matcher :to_method_symbol, <<~PATTERN
-          {(send _ $_ ${(sym ${#{METHODS}})} ...)
-           (send _ $_ ${(block_pass (sym ${#{METHODS}}))} ...)}
+          (call _ $_ ${
+            {
+              (sym ${#{METHODS}})
+              (block_pass (sym ${#{METHODS}}))
+            }
+          } ...)
         PATTERN
 
         def on_send(node)
           handle_conversion_method(node)
           handle_as_symbol(node)
         end
+        alias on_csend on_send
 
         private
 
         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 +122,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 +162,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 +174,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

@@ -6,13 +6,13 @@ module RuboCop
       # Checks for uses of numbered parameter assignment.
       # It emulates the following warning in Ruby 2.7:
       #
-      #   % ruby -ve '_1 = :value'
+      #   $ ruby -ve '_1 = :value'
       #   ruby 2.7.2p137 (2020-10-01 revision 5445e04352) [x86_64-darwin19]
       #   -e:1: warning: `_1' is reserved for numbered parameter; consider another name
       #
       # Assigning to a numbered parameter (from `_1` to `_9`) causes an error in Ruby 3.0.
       #
-      #   % ruby -ve '_1 = :value'
+      #   $ ruby -ve '_1 = :value'
       #   ruby 3.0.0p0 (2020-12-25 revision 95aff21468) [x86_64-darwin19]
       #   -e:1: _1 is reserved for numbered parameter
       #

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

@@ -31,6 +31,8 @@ module RuboCop
           return unless lhs&.casgn_type?
 
           add_offense(node.loc.operator) do |corrector|
+            next if node.each_ancestor(:def, :defs).any?
+
             corrector.replace(node.loc.operator, '=')
           end
         end

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

@@ -3,10 +3,12 @@
 module RuboCop
   module Cop
     module Lint
-      #
       # Checks the proper ordering of magic comments and whether
       # a magic comment is not placed before a shebang.
       #
+      # @safety
+      #   This cop's autocorrection is unsafe because file encoding may change.
+      #
       # @example
       #   # bad
       #
@@ -61,7 +63,7 @@ module RuboCop
         def magic_comment_lines
           lines = [nil, nil]
 
-          magic_comments.each.with_index do |comment, index|
+          leading_magic_comments.each.with_index do |comment, index|
             if comment.encoding_specified?
               lines[0] = index
             elsif comment.frozen_string_literal_specified?
@@ -73,10 +75,6 @@ module RuboCop
 
           lines
         end
-
-        def magic_comments
-          leading_comment_lines.map { |line| MagicComment.parse(line) }
-        end
       end
     end
   end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cops looks for references of Regexp captures that are out of range
+      # Looks for references of Regexp captures that are out of range
       # and thus always returns nil.
       #
       # @safety
@@ -65,7 +65,13 @@ module RuboCop
         def on_when(node)
           regexp_conditions = node.conditions.select(&:regexp_type?)
 
-          @valid_ref = regexp_conditions.map { |condition| check_regexp(condition) }.compact.max
+          @valid_ref = regexp_conditions.filter_map { |condition| check_regexp(condition) }.max
+        end
+
+        def on_in_pattern(node)
+          regexp_patterns = regexp_patterns(node)
+
+          @valid_ref = regexp_patterns.filter_map { |pattern| check_regexp(pattern) }.max
         end
 
         def on_nth_ref(node)
@@ -84,6 +90,15 @@ module RuboCop
 
         private
 
+        def regexp_patterns(in_node)
+          pattern = in_node.pattern
+          if pattern.regexp_type?
+            [pattern]
+          else
+            pattern.each_descendant(:regexp).to_a
+          end
+        end
+
         def check_regexp(node)
           return if node.interpolation?
 

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

@@ -40,11 +40,16 @@ module RuboCop
           unless node.arguments.one? && first_argument_starts_with_left_parenthesis?(node)
             return true
           end
+          return true if first_argument_block_type?(node.first_argument)
 
           node.operator_method? || node.setter_method? || chained_calls?(node) ||
             valid_first_argument?(node.first_argument)
         end
 
+        def first_argument_block_type?(first_arg)
+          first_arg.block_type? || first_arg.numblock_type?
+        end
+
         def valid_first_argument?(first_arg)
           first_arg.operator_keyword? || first_arg.hash_type? || ternary_expression?(first_arg)
         end
@@ -55,7 +60,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

@@ -50,7 +50,7 @@ module RuboCop
 
           add_offense(node) do |corrector|
             node.each_value do |value|
-              range = value.loc.expression
+              range = value.source_range
 
               match = range.source.match(TRAILING_QUOTE)
               corrector.remove_trailing(range, match[0].length) if match

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

@@ -41,7 +41,7 @@ module RuboCop
 
         def autocorrect(corrector, node)
           node.children.each do |child|
-            range = child.loc.expression
+            range = child.source_range
 
             corrector.remove_trailing(range, 1) if range.source.end_with?(',')
             corrector.remove_leading(range, 1) if

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

@@ -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)
@@ -113,6 +113,7 @@ module RuboCop
         def each_line_range(cop, line_ranges)
           line_ranges.each_with_index do |line_range, line_range_index|
             next if ignore_offense?(line_range)
+            next if expected_final_disable?(cop, line_range)
 
             comment = processed_source.comment_at_line(line_range.begin)
             redundant = if all_disabled?(comment)
@@ -127,23 +128,35 @@ module RuboCop
           end
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def each_already_disabled(cop, line_ranges)
           line_ranges.each_cons(2) do |previous_range, range|
             next if ignore_offense?(range)
-            next unless followed_ranges?(previous_range, range)
-
             # If a cop is disabled in a range that begins on the same line as
             # the end of the previous range, it means that the cop was
             # already disabled by an earlier comment. So it's redundant
             # whether there are offenses or not.
+            next unless followed_ranges?(previous_range, range)
+
             comment = processed_source.comment_at_line(range.begin)
 
+            next unless comment
             # Comments disabling all cops don't count since it's reasonable
             # to disable a few select cops first and then all cops further
             # down in the code.
-            yield comment, cop if comment && !all_disabled?(comment)
+            next if all_disabled?(comment)
+
+            redundant =
+              if department_disabled?(cop, comment)
+                find_redundant_department(cop, range)
+              else
+                cop
+              end
+
+            yield comment, redundant if redundant
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def find_redundant_cop(cop, range)
           cop_offenses = offenses_to_check.select { |offense| offense.cop_name == cop }
@@ -179,11 +192,21 @@ module RuboCop
         end
 
         def ignore_offense?(line_range)
+          return true if line_range.min == CommentConfig::CONFIG_DISABLED_LINE_RANGE_MIN
+
           disabled_ranges.any? do |range|
             range.cover?(line_range.min) && range.cover?(line_range.max)
           end
         end
 
+        def expected_final_disable?(cop, line_range)
+          # A cop which is disabled in the config is being re-disabled until end of file
+          cop_class = RuboCop::Cop::Registry.global.find_by_cop_name cop
+          cop_class &&
+            !processed_source.registry.enabled?(cop_class, config) &&
+            line_range.max == Float::INFINITY
+        end
+
         def department_disabled?(cop, comment)
           directive = DirectiveComment.new(comment)
           directive.in_directive_department?(cop) && !directive.overridden_by_department?(cop)
@@ -208,8 +231,13 @@ module RuboCop
           cop_names = cops.sort.map { |c| describe(c) }.join(', ')
 
           add_offense(location, message: message(cop_names)) do |corrector|
-            range = comment_range_with_surrounding_space(location, comment.loc.expression)
-            corrector.remove(range)
+            range = comment_range_with_surrounding_space(location, comment.source_range)
+
+            if leave_free_comment?(comment, range)
+              corrector.replace(range, ' # ')
+            else
+              corrector.remove(range)
+            end
           end
         end
 
@@ -227,10 +255,16 @@ module RuboCop
           end
         end
 
+        def leave_free_comment?(comment, range)
+          free_comment = comment.text.gsub(range.source.strip, '')
+
+          !free_comment.empty? && !free_comment.start_with?('#')
+        end
+
         def cop_range(comment, cop)
           cop = remove_department_marker(cop)
-          matching_range(comment.loc.expression, cop) ||
-            matching_range(comment.loc.expression, Badge.parse(cop).cop_name) ||
+          matching_range(comment.source_range, cop) ||
+            matching_range(comment.source_range, Badge.parse(cop).cop_name) ||
             raise("Couldn't find #{cop} in comment: #{comment.text}")
         end
 
@@ -247,15 +281,21 @@ module RuboCop
             .drop_while { |r| !r.equal?(range) }
             .each_cons(2)
             .map { |range1, range2| range1.end.join(range2.begin).source }
-            .all? { |intervening| /\A\s*,\s*\Z/.match?(intervening) }
+            .all?(/\A\s*,\s*\z/)
+        end
+
+        SIMILAR_COP_NAMES_CACHE = Hash.new do |hash, cop_name|
+          hash[:all_cop_names] = Registry.global.names unless hash.key?(:all_cop_names)
+          hash[cop_name] = NameSimilarity.find_similar_name(cop_name, hash[:all_cop_names])
         end
+        private_constant :SIMILAR_COP_NAMES_CACHE
 
         def describe(cop)
           return 'all cops' if cop == 'all'
           return "`#{remove_department_marker(cop)}` department" if department_marker?(cop)
           return "`#{cop}`" if all_cop_names.include?(cop)
 
-          similar = NameSimilarity.find_similar_name(cop, all_cop_names)
+          similar = SIMILAR_COP_NAMES_CACHE[cop]
           similar ? "`#{cop}` (did you mean `#{similar}`?)" : "`#{cop}` (unknown cop)"
         end