rubocop 1.50.2 → 1.59.0

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

@@ -43,7 +43,6 @@ module RuboCop
       #
       class NonAtomicFileOperation < Base
         extend AutoCorrector
-        include Alignment
 
         MSG_REMOVE_FILE_EXIST_CHECK = 'Remove unnecessary existence check ' \
                                       '`%<receiver>s.%<method_name>s`.'
@@ -51,18 +50,20 @@ module RuboCop
         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
+        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
+        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
+        def_node_matcher :receiver_and_method_name, <<~PATTERN
           (send (const nil? $_) $_ ...)
         PATTERN
 
@@ -140,6 +141,8 @@ module RuboCop
             '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

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

@@ -94,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)
@@ -116,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})")
@@ -130,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.with(begin_pos: node.arguments[-2].source_range.end_pos)
         end
 
         def unsorted_dir_loop?(node)

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

@@ -9,7 +9,7 @@ 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.
       #
@@ -74,6 +74,7 @@ module RuboCop
         extend AutoCorrector
         include AllowedMethods
         include AllowedPattern
+        include IgnoredNode
 
         CONVERSION_METHOD_CLASS_MAPPING = {
           to_i: "#{Integer.name}(%<number_object>s, 10)",
@@ -90,19 +91,24 @@ module RuboCop
 
         # @!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
 
@@ -116,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

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/ordered_magic_comments.rb

@@ -3,7 +3,6 @@
 module RuboCop
   module Cop
     module Lint
-      #
       # Checks the proper ordering of magic comments and whether
       # a magic comment is not placed before a shebang.
       #

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

@@ -65,13 +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.map { |pattern| check_regexp(pattern) }.compact.max
+          @valid_ref = regexp_patterns.filter_map { |pattern| check_regexp(pattern) }.max
         end
 
         def on_nth_ref(node)

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

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for redundant quantifiers inside Regexp literals.
+      #
+      # It is always allowed when interpolation is used in a regexp literal,
+      # because it's unknown what kind of string will be expanded as a result:
+      #
+      # [source,ruby]
+      # ----
+      # /(?:a*#{interpolation})?/x
+      # ----
+      #
+      # @example
+      #   # bad
+      #   /(?:x+)+/
+      #
+      #   # good
+      #   /(?:x)+/
+      #
+      #   # good
+      #   /(?:x+)/
+      #
+      #   # bad
+      #   /(?:x+)?/
+      #
+      #   # good
+      #   /(?:x)*/
+      #
+      #   # good
+      #   /(?:x*)/
+      class RedundantRegexpQuantifiers < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG_REDUNDANT_QUANTIFIER = 'Replace redundant quantifiers ' \
+                                   '`%<inner_quantifier>s` and `%<outer_quantifier>s` ' \
+                                   'with a single `%<replacement>s`.'
+
+        def on_regexp(node)
+          return if node.interpolation?
+
+          each_redundantly_quantified_pair(node) do |group, child|
+            replacement = merged_quantifier(group, child)
+            add_offense(
+              quantifier_range(group, child),
+              message: message(group, child, replacement)
+            ) do |corrector|
+              # drop outer quantifier
+              corrector.replace(group.loc.quantifier, '')
+              # replace inner quantifier
+              corrector.replace(child.loc.quantifier, replacement)
+            end
+          end
+        end
+
+        private
+
+        def each_redundantly_quantified_pair(node)
+          seen = Set.new
+          node.parsed_tree&.each_expression do |(expr)|
+            next if seen.include?(expr) || !redundant_group?(expr) || !mergeable_quantifier(expr)
+
+            expr.each_expression do |(subexp)|
+              seen << subexp
+              break unless redundantly_quantifiable?(subexp)
+
+              yield(expr, subexp) if mergeable_quantifier(subexp)
+            end
+          end
+        end
+
+        def redundant_group?(expr)
+          expr.is?(:passive, :group) && expr.count { |child| child.type != :free_space } == 1
+        end
+
+        def redundantly_quantifiable?(node)
+          redundant_group?(node) || character_set?(node) || node.terminal?
+        end
+
+        def character_set?(expr)
+          expr.is?(:character, :set)
+        end
+
+        def mergeable_quantifier(expr)
+          # Merging reluctant or possessive quantifiers would be more complex,
+          # and Ruby does not emit warnings for these cases.
+          return unless expr.quantifier&.greedy?
+
+          # normalize quantifiers, e.g. "{1,}" => "+"
+          case expr.quantity
+          when [0, -1]
+            '*'
+          when [0, 1]
+            '?'
+          when [1, -1]
+            '+'
+          end
+        end
+
+        def merged_quantifier(exp1, exp2)
+          quantifier1 = mergeable_quantifier(exp1)
+          quantifier2 = mergeable_quantifier(exp2)
+          if quantifier1 == quantifier2
+            # (?:a+)+ equals (?:a+) ; (?:a*)* equals (?:a*) ; # (?:a?)? equals (?:a?)
+            quantifier1
+          else
+            # (?:a+)*, (?:a+)?, (?:a*)+, (?:a*)?, (?:a?)+, (?:a?)* - all equal (?:a*)
+            '*'
+          end
+        end
+
+        def quantifier_range(group, child)
+          range_between(child.loc.quantifier.begin_pos, group.loc.quantifier.end_pos)
+        end
+
+        def message(group, child, replacement)
+          format(
+            MSG_REDUNDANT_QUANTIFIER,
+            inner_quantifier: child.quantifier.to_s,
+            outer_quantifier: group.quantifier.to_s,
+            replacement: replacement
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -24,6 +24,10 @@ module RuboCop
       #
       # This cop target those features.
       #
+      # @safety
+      #   This cop's autocorrection is unsafe because if `require 'pp'` is removed from one file,
+      #   `NameError` can be encountered when another file uses `PP.pp`.
+      #
       # @example
       #   # bad
       #   require 'unloaded_feature'
@@ -49,6 +53,11 @@ module RuboCop
             (str #redundant_feature?))
         PATTERN
 
+        # @!method pp_const?(node)
+        def_node_matcher :pp_const?, <<~PATTERN
+          (const {nil? cbase} :PP)
+        PATTERN
+
         def on_send(node)
           return unless redundant_require_statement?(node)
 
@@ -72,16 +81,16 @@ module RuboCop
           feature_name == 'enumerator' ||
             (target_ruby_version >= 2.1 && feature_name == 'thread') ||
             (target_ruby_version >= 2.2 && RUBY_22_LOADED_FEATURES.include?(feature_name)) ||
-            (target_ruby_version >= 2.5 && feature_name == 'pp' && !use_pretty_print_method?) ||
+            (target_ruby_version >= 2.5 && feature_name == 'pp' && !need_to_require_pp?) ||
             (target_ruby_version >= 2.7 && feature_name == 'ruby2_keywords') ||
             (target_ruby_version >= 3.1 && feature_name == 'fiber') ||
             (target_ruby_version >= 3.2 && feature_name == 'set')
         end
         # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
-        def use_pretty_print_method?
+        def need_to_require_pp?
           processed_source.ast.each_descendant(:send).any? do |node|
-            PRETTY_PRINT_METHODS.include?(node.method_name)
+            pp_const?(node.receiver) || PRETTY_PRINT_METHODS.include?(node.method_name)
           end
         end
       end

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

@@ -4,8 +4,12 @@ module RuboCop
   module Cop
     module Lint
       # 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.
+      # Use cases where a constant, named in camel case for classes and modules is `nil` are rare,
+      # and an offense is not detected when the receiver is a snake case constant.
+      #
+      # For all receivers, the `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.
@@ -22,6 +26,9 @@ module RuboCop
       #
       # @example
       #   # bad
+      #   CamelCaseConst&.do_something
+      #
+      #   # bad
       #   do_something if attrs&.respond_to?(:[])
       #
       #   # good
@@ -33,6 +40,9 @@ module RuboCop
       #   end
       #
       #   # good
+      #   CamelCaseConst.do_something
+      #
+      #   # good
       #   while node.is_a?(BeginNode)
       #     node = node.parent
       #   end
@@ -40,6 +50,22 @@ module RuboCop
       #   # good - without `&.` this will always return `true`
       #   foo&.respond_to?(:to_a)
       #
+      #   # bad - for `nil`s conversion methods return default values for the type
+      #   foo&.to_h || {}
+      #   foo&.to_h { |k, v| [k, v] } || {}
+      #   foo&.to_a || []
+      #   foo&.to_i || 0
+      #   foo&.to_f || 0.0
+      #   foo&.to_s || ''
+      #
+      #   # good
+      #   foo.to_h
+      #   foo.to_h { |k, v| [k, v] }
+      #   foo.to_a
+      #   foo.to_i
+      #   foo.to_f
+      #   foo.to_s
+      #
       # @example AllowedMethods: [nil_safe_method]
       #   # bad
       #   do_something if attrs&.nil_safe_method(:[])
@@ -54,22 +80,55 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Redundant safe navigation detected.'
+        MSG_LITERAL = 'Redundant safe navigation with default literal detected.'
 
         NIL_SPECIFIC_METHODS = (nil.methods - Object.new.methods).to_set.freeze
 
+        SNAKE_CASE = /\A[[:digit:][:upper:]_]+\z/.freeze
+
         # @!method respond_to_nil_specific_method?(node)
         def_node_matcher :respond_to_nil_specific_method?, <<~PATTERN
           (csend _ :respond_to? (sym %NIL_SPECIFIC_METHODS))
         PATTERN
 
+        # @!method conversion_with_default?(node)
+        def_node_matcher :conversion_with_default?, <<~PATTERN
+          {
+            (or $(csend _ :to_h) (hash))
+            (or (block $(csend _ :to_h) ...) (hash))
+            (or $(csend _ :to_a) (array))
+            (or $(csend _ :to_i) (int 0))
+            (or $(csend _ :to_f) (float 0.0))
+            (or $(csend _ :to_s) (str empty?))
+          }
+        PATTERN
+
+        # rubocop:disable Metrics/AbcSize
         def on_csend(node)
-          return unless check?(node) && allowed_method?(node.method_name)
-          return if respond_to_nil_specific_method?(node)
+          unless node.receiver.const_type? && !node.receiver.source.match?(SNAKE_CASE)
+            return unless check?(node) && allowed_method?(node.method_name)
+            return if respond_to_nil_specific_method?(node)
+          end
 
           range = range_between(node.loc.dot.begin_pos, node.source_range.end_pos)
           add_offense(range) { |corrector| corrector.replace(node.loc.dot, '.') }
         end
 
+        def on_or(node)
+          conversion_with_default?(node) do |send_node|
+            range = range_between(send_node.loc.dot.begin_pos, node.source_range.end_pos)
+
+            add_offense(range, message: MSG_LITERAL) do |corrector|
+              corrector.replace(send_node.loc.dot, '.')
+
+              range_with_default = range_between(node.lhs.source_range.end.begin_pos,
+                                                 node.source_range.end.end_pos)
+              corrector.remove(range_with_default)
+            end
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
         private
 
         def check?(node)

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

@@ -47,7 +47,7 @@ module RuboCop
           return if node.receiver
 
           node.each_child_node(:send) do |child|
-            next unless child.method?(:to_s)
+            next if !child.method?(:to_s) || child.arguments.any?
 
             register_offense(child, "`#{node.method_name}`")
           end

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

@@ -56,10 +56,10 @@ module RuboCop
         def_node_matcher :redundant_with_index?, <<~PATTERN
           {
             (block
-              $(send _ {:each_with_index :with_index} ...)
+              $(call _ {:each_with_index :with_index} ...)
               (args (arg _)) ...)
             (numblock
-              $(send _ {:each_with_index :with_index} ...) 1 ...)
+              $(call _ {:each_with_index :with_index} ...) 1 ...)
           }
         PATTERN
 

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

@@ -56,9 +56,9 @@ module RuboCop
         def_node_matcher :redundant_with_object?, <<~PATTERN
           {
             (block
-              $(send _ {:each_with_object :with_object} _) (args (arg _)) ...)
+              $(call _ {:each_with_object :with_object} _) (args (arg _)) ...)
             (numblock
-              $(send _ {:each_with_object :with_object} _) 1 ...)
+              $(call _ {:each_with_object :with_object} _) 1 ...)
           }
         PATTERN
 

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

@@ -45,10 +45,9 @@ module RuboCop
           bad_method?(node) do |safe_nav, method|
             return if nil_methods.include?(method) || PLUS_MINUS_METHODS.include?(node.method_name)
 
-            location =
-              Parser::Source::Range.new(node.source_range.source_buffer,
-                                        safe_nav.source_range.end_pos,
-                                        node.source_range.end_pos)
+            begin_range = node.loc.dot || safe_nav.source_range.end
+            location = begin_range.join(node.source_range.end)
+
             add_offense(location) do |corrector|
               autocorrect(corrector, offense_range: location, send_node: node)
             end
@@ -82,16 +81,23 @@ module RuboCop
         def autocorrect(corrector, offense_range:, send_node:)
           corrector.replace(
             offense_range,
-            add_safe_navigation_operator(
-              offense_range: offense_range,
-              send_node: send_node
-            )
+            add_safe_navigation_operator(offense_range: offense_range, send_node: send_node)
           )
+
+          corrector.wrap(send_node, '(', ')') if require_parentheses?(send_node)
         end
 
         def brackets?(send_node)
           send_node.method?(:[]) || send_node.method?(:[]=)
         end
+
+        def require_parentheses?(send_node)
+          return false unless send_node.comparison_method?
+          return false unless (node = send_node.parent)
+
+          (node.respond_to?(:logical_operator?) && node.logical_operator?) ||
+            (node.respond_to?(:comparison_method?) && node.comparison_method?)
+        end
       end
     end
   end

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

@@ -10,11 +10,18 @@ module RuboCop
       #   foo = foo
       #   foo, bar = foo, bar
       #   Foo = Foo
+      #   hash['foo'] = hash['foo']
+      #   obj.attr = obj.attr
       #
       #   # good
       #   foo = bar
       #   foo, bar = bar, foo
       #   Foo = Bar
+      #   hash['foo'] = hash['bar']
+      #   obj.attr = obj.attr2
+      #
+      #   # good (method calls possibly can return different results)
+      #   hash[foo] = hash[foo]
       #
       class SelfAssignment < Base
         MSG = 'Self-assignment detected.'
@@ -26,6 +33,15 @@ module RuboCop
           gvasgn: :gvar
         }.freeze
 
+        def on_send(node)
+          if node.method?(:[]=)
+            handle_key_assignment(node) if node.arguments.size == 2
+          elsif node.assignment_method?
+            handle_attribute_assignment(node) if node.arguments.size == 1
+          end
+        end
+        alias on_csend on_send
+
         def on_lvasgn(node)
           lhs, rhs = *node
           return unless rhs
@@ -72,6 +88,28 @@ module RuboCop
           rhs.type == ASSIGNMENT_TYPE_TO_RHS_TYPE[lhs.type] &&
             rhs.children.first == lhs.children.first
         end
+
+        def handle_key_assignment(node)
+          value_node = node.arguments[1]
+
+          if value_node.send_type? && value_node.method?(:[]) &&
+             node.receiver == value_node.receiver &&
+             !node.first_argument.call_type? &&
+             node.first_argument == value_node.first_argument
+            add_offense(node)
+          end
+        end
+
+        def handle_attribute_assignment(node)
+          first_argument = node.first_argument
+          return unless first_argument.respond_to?(:arguments) && first_argument.arguments.empty?
+
+          if first_argument.call_type? &&
+             node.receiver == first_argument.receiver &&
+             first_argument.method_name.to_s == node.method_name.to_s.delete_suffix('=')
+            add_offense(node)
+          end
+        end
       end
     end
   end

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

@@ -3,8 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      #
-      # This cop checks for `send`, `public_send`, and `__send__` methods
+      # Checks for `send`, `public_send`, and `__send__` methods
       # when using mix-in.
       #
       # `include` and `prepend` methods were private methods until Ruby 2.0,

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

@@ -121,18 +121,12 @@ module RuboCop
 
           if rescued_exceptions.any?
             rescued_exceptions.each_with_object([]) do |exception, converted|
-              # FIXME: Workaround `rubocop:disable` comment for JRuby.
-              #        https://github.com/jruby/jruby/issues/6642
-              # rubocop:disable Style/RedundantBegin
-              begin
-                RuboCop::Util.silence_warnings do
-                  # Avoid printing deprecation warnings about constants
-                  converted << Kernel.const_get(exception.source)
-                end
-              rescue NameError
-                converted << nil
+              RuboCop::Util.silence_warnings do
+                # Avoid printing deprecation warnings about constants
+                converted << Kernel.const_get(exception.source)
               end
-              # rubocop:enable Style/RedundantBegin
+            rescue NameError
+              converted << nil
             end
           else
             # treat an empty `rescue` as `rescue StandardError`

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

@@ -68,7 +68,7 @@ module RuboCop
 
         def same_conditions_node_different_branch?(variable, outer_local_variable)
           variable_node = variable_node(variable)
-          return false unless variable_node.conditional?
+          return false unless node_or_its_ascendant_conditional?(variable_node)
 
           outer_local_variable_node =
             find_conditional_node_from_ascendant(outer_local_variable.declaration_node)
@@ -96,6 +96,12 @@ module RuboCop
 
           find_conditional_node_from_ascendant(parent)
         end
+
+        def node_or_its_ascendant_conditional?(node)
+          return true if node.conditional?
+
+          !!find_conditional_node_from_ascendant(node)
+        end
       end
     end
   end