rubocop 0.93.1 → 1.79.2

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

@@ -0,0 +1,174 @@
+# 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 {cbase nil?} {:FileTest :File :Dir :Shell}) {:exist? :exists?} ...)
+        PATTERN
+
+        # @!method receiver_and_method_name(node)
+        def_node_matcher :receiver_and_method_name, <<~PATTERN
+          (send (const {cbase 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 node.receiver&.const_type?
+          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.operator_keyword? || 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))
+          corrector.insert_before(node.last_argument, 'mode: ') if require_mode_keyword?(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 require_mode_keyword?(node)
+          return false unless node.receiver.const_name == 'Dir'
+
+          replacement_method(node) == 'mkdir_p' && node.arguments.length == 2
+        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

@@ -11,6 +11,15 @@ module RuboCop
       # that are hard to debug. To ensure this doesn't happen,
       # always sort the list.
       #
+      # `Dir.glob` and `Dir[]` sort globbed results by default in Ruby 3.0.
+      # So all bad cases are acceptable when Ruby 3.0 or higher are used.
+      #
+      # NOTE: This cop will be deprecated and removed when supporting only Ruby 3.0 and higher.
+      #
+      # @safety
+      #   This cop is unsafe in the case where sorting files changes existing
+      #   expected behavior.
+      #
       # @example
       #
       #   # bad
@@ -23,8 +32,6 @@ module RuboCop
       #     require file
       #   end
       #
-      # @example
-      #
       #   # bad
       #   Dir.glob(Rails.root.join(__dir__, 'test', '*.rb')) do |file|
       #     require file
@@ -35,27 +42,29 @@ module RuboCop
       #     require file
       #   end
       #
-      # @example
-      #
       #   # bad
       #   Dir['./lib/**/*.rb'].each(&method(:require))
       #
       #   # good
       #   Dir['./lib/**/*.rb'].sort.each(&method(:require))
       #
-      # @example
-      #
       #   # bad
       #   Dir.glob(Rails.root.join('test', '*.rb'), &method(:require))
       #
       #   # good
       #   Dir.glob(Rails.root.join('test', '*.rb')).sort.each(&method(:require))
       #
+      #   # good - Respect intent if `sort` keyword option is specified in Ruby 3.0 or higher.
+      #   Dir.glob(Rails.root.join(__dir__, 'test', '*.rb'), sort: false).each(&method(:require))
+      #
       class NonDeterministicRequireOrder < Base
         extend AutoCorrector
+        extend TargetRubyVersion
 
         MSG = 'Sort files before requiring them.'
 
+        maximum_target_ruby_version 2.7
+
         def on_block(node)
           return unless node.body
           return unless unsorted_dir_loop?(node.send_node)
@@ -63,12 +72,21 @@ module RuboCop
           loop_variable(node.arguments) do |var_name|
             return unless var_is_required?(node.body, var_name)
 
-            add_offense(node.send_node) do |corrector|
-              correct_block(corrector, node.send_node)
-            end
+            add_offense(node.send_node) { |corrector| correct_block(corrector, node.send_node) }
           end
         end
 
+        def on_numblock(node)
+          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 unless method_require?(node)
           return unless unsorted_dir_pass?(node.parent)
@@ -76,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)
@@ -98,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})")
@@ -112,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)
@@ -125,34 +141,41 @@ module RuboCop
           unsorted_dir_glob_pass?(node) || unsorted_dir_each_pass?(node)
         end
 
+        # @!method unsorted_dir_block?(node)
         def_node_matcher :unsorted_dir_block?, <<~PATTERN
           (send (const {nil? cbase} :Dir) :glob ...)
         PATTERN
 
+        # @!method unsorted_dir_each?(node)
         def_node_matcher :unsorted_dir_each?, <<~PATTERN
           (send (send (const {nil? cbase} :Dir) {:[] :glob} ...) :each)
         PATTERN
 
+        # @!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)
         def_node_matcher :loop_variable, <<~PATTERN
           (args (arg $_))
         PATTERN
 
+        # @!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,
@@ -46,7 +46,7 @@ module RuboCop
         def on_return(return_node)
           return if return_value?(return_node)
 
-          return_node.each_ancestor(:block, :def, :defs) do |node|
+          return_node.each_ancestor(:any_block, :any_def) do |node|
             break if scoped_node?(node)
 
             # if a proc is passed to `Module#define_method` or
@@ -54,7 +54,7 @@ module RuboCop
             # non-local exit error
             break if define_method?(node.send_node)
 
-            next unless node.arguments?
+            next if node.argument_list.empty?
 
             if chained_send?(node.send_node)
               add_offense(return_node.loc.keyword)
@@ -66,14 +66,17 @@ module RuboCop
         private
 
         def scoped_node?(node)
-          node.def_type? || node.defs_type? || node.lambda?
+          node.any_def_type? || node.lambda?
         end
 
         def return_value?(return_node)
           !return_node.children.empty?
         end
 
+        # @!method chained_send?(node)
         def_node_matcher :chained_send?, '(send !nil? ...)'
+
+        # @!method define_method?(node)
         def_node_matcher :define_method?, <<~PATTERN
           (send _ {:define_method :define_singleton_method} _)
         PATTERN

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

@@ -3,10 +3,27 @@
 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.
       #
+      # 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``).
+      # 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 allowed with `AllowedMethods`. By default,
+      # there are no methods to allowed.
+      #
+      # @safety
+      #   Autocorrection is unsafe because it is not guaranteed that the
+      #   replacement `Kernel` methods are able to properly handle the
+      #   input if it is not a standard class.
+      #
       # @example
       #
       #   # bad
@@ -14,64 +31,168 @@ module RuboCop
       #   '10'.to_i
       #   '10.2'.to_f
       #   '10'.to_c
+      #   '1/3'.to_r
+      #   ['1', '2', '3'].map(&:to_i)
+      #   foo.try(:to_f)
+      #   bar.send(:to_c)
       #
       #   # good
       #
       #   Integer('10', 10)
       #   Float('10.2')
       #   Complex('10')
+      #   Rational('1/3')
+      #   ['1', '2', '3'].map { |i| Integer(i, 10) }
+      #   foo.try { |i| Float(i) }
+      #   bar.send { |i| Complex(i) }
+      #
+      # @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
+      #
+      # @example IgnoredClasses: [Time, DateTime] (default)
+      #
+      #   # good
+      #   Time.now.to_datetime.to_i
       class NumberConversion < Base
         extend AutoCorrector
+        include AllowedMethods
+        include AllowedPattern
 
         CONVERSION_METHOD_CLASS_MAPPING = {
           to_i: "#{Integer.name}(%<number_object>s, 10)",
           to_f: "#{Float.name}(%<number_object>s)",
-          to_c: "#{Complex.name}(%<number_object>s)"
+          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 '\
-              '%<number_object>s.%<to_method>s, use stricter '\
-              '%<corrected_method>s.'
-        RESTRICT_ON_SEND = CONVERSION_METHOD_CLASS_MAPPING.keys.freeze
+        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 $_ ${:to_i :to_f :to_c})
+          (call $_ ${#{METHODS}})
         PATTERN
 
-        def_node_matcher :datetime?, <<~PATTERN
-          (send (const {nil? (cbase)} {:Time :DateTime}) ...)
+        # @!method to_method_symbol(node)
+        def_node_matcher :to_method_symbol, <<~PATTERN
+          (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? || date_time_object?(receiver)
+            next if receiver.nil? || allow_receiver?(receiver)
 
             message = format(
               MSG,
-              number_object: receiver.source,
-              to_method: to_method,
+              current: "#{receiver.source}.#{to_method}",
               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
 
-        private
+        def handle_as_symbol(node)
+          to_method_symbol(node) do |receiver, sym_node, to_method|
+            next if receiver.nil? || !node.arguments.one?
 
-        def date_time_object?(node)
-          child = node
-          while child&.send_type?
-            return true if datetime? child
+            message = format(
+              MSG,
+              current: sym_node.source,
+              corrected_method: correct_sym_method(to_method)
+            )
+            add_offense(node, message: message) do |corrector|
+              remove_parentheses(corrector, node) if node.parenthesized?
 
-            child = child.children[0]
+              corrector.replace(sym_node, correct_sym_method(to_method))
+            end
           end
         end
 
         def correct_method(node, receiver)
-          format(CONVERSION_METHOD_CLASS_MAPPING[node.method_name],
-                 number_object: receiver.source)
+          format(CONVERSION_METHOD_CLASS_MAPPING[node.method_name], number_object: receiver.source)
+        end
+
+        def correct_sym_method(to_method)
+          body = format(CONVERSION_METHOD_CLASS_MAPPING[to_method], number_object: 'i')
+          "{ |i| #{body} }"
+        end
+
+        def remove_parentheses(corrector, node)
+          corrector.replace(node.loc.begin, ' ')
+          corrector.remove(node.loc.end)
+        end
+
+        def allow_receiver?(receiver)
+          if receiver.numeric_type? || (receiver.send_type? &&
+            (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)
+          else
+            false
+          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?
+          receiver
+        end
+
+        def conversion_method?(method_name)
+          CONVERSION_METHODS.include?(method_name)
+        end
+
+        def ignored_classes
+          cop_config.fetch('IgnoredClasses', [])
+        end
+
+        def ignored_class?(name)
+          ignored_classes.include?(name.to_s)
         end
       end
     end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for uses of numbered parameter assignment.
+      # It emulates the following warning in Ruby 2.7:
+      #
+      #   $ 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 3.0.0p0 (2020-12-25 revision 95aff21468) [x86_64-darwin19]
+      #   -e:1: _1 is reserved for numbered parameter
+      #
+      # NOTE: The parametered parameters are from `_1` to `_9`. This cop checks `_0`, and over `_10`
+      # as well to prevent confusion.
+      #
+      # @example
+      #
+      #   # bad
+      #   _1 = :value
+      #
+      #   # good
+      #   non_numbered_parameter_name = :value
+      #
+      class NumberedParameterAssignment < Base
+        NUM_PARAM_MSG = '`_%<number>s` is reserved for numbered parameter; consider another name.'
+        LVAR_MSG = '`_%<number>s` is similar to numbered parameter; consider another name.'
+        NUMBERED_PARAMETER_RANGE = (1..9).freeze
+
+        def on_lvasgn(node)
+          return unless /\A_(\d+)\z/ =~ node.name
+
+          number = Regexp.last_match(1).to_i
+          template = NUMBERED_PARAMETER_RANGE.include?(number) ? NUM_PARAM_MSG : LVAR_MSG
+
+          add_offense(node, message: format(template, number: number))
+        end
+      end
+    end
+  end
+end