rubocop 1.41.1 → 1.57.1

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

@@ -231,7 +231,7 @@ 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)
+            range = comment_range_with_surrounding_space(location, comment.source_range)
 
             if leave_free_comment?(comment, range)
               corrector.replace(range, ' # ')
@@ -263,8 +263,8 @@ module RuboCop
 
         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
 
@@ -281,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
 

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

@@ -74,7 +74,7 @@ module RuboCop
         end
 
         def comment_start(comment)
-          comment.loc.expression.begin_pos
+          comment.source_range.begin_pos
         end
 
         def cop_name_indention(comment, name)
@@ -82,7 +82,7 @@ module RuboCop
         end
 
         def range_with_comma(comment, name)
-          source = comment.loc.expression.source
+          source = comment.source
 
           begin_pos = cop_name_indention(comment, name)
           end_pos = begin_pos + name.size
@@ -94,14 +94,14 @@ module RuboCop
 
         def range_to_remove(begin_pos, end_pos, comment)
           start = comment_start(comment)
-          source = comment.loc.expression.source
+          source = comment.source
 
           if source[begin_pos - 1] == ','
             range_with_comma_before(start, begin_pos, end_pos)
           elsif source[end_pos] == ','
             range_with_comma_after(comment, start, begin_pos, end_pos)
           else
-            range_between(start, comment.loc.expression.end_pos)
+            range_between(start, comment.source_range.end_pos)
           end
         end
 
@@ -112,7 +112,7 @@ module RuboCop
         # If the list of cops is comma-separated, but without a empty space after the comma,
         # we should **not** remove the prepending empty space, thus begin_pos += 1
         def range_with_comma_after(comment, start, begin_pos, end_pos)
-          begin_pos += 1 if comment.loc.expression.source[end_pos + 1] != ' '
+          begin_pos += 1 if comment.source[end_pos + 1] != ' '
 
           range_between(start + begin_pos, start + end_pos + 1)
         end

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'
@@ -38,6 +42,10 @@ module RuboCop
         MSG = 'Remove unnecessary `require` statement.'
         RESTRICT_ON_SEND = %i[require].freeze
         RUBY_22_LOADED_FEATURES = %w[rational complex].freeze
+        PRETTY_PRINT_METHODS = %i[
+          pretty_inspect pretty_print pretty_print_cycle
+          pretty_print_inspect pretty_print_instance_variables
+        ].freeze
 
         # @!method redundant_require_statement?(node)
         def_node_matcher :redundant_require_statement?, <<~PATTERN
@@ -45,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)
 
@@ -52,7 +65,7 @@ module RuboCop
             if node.parent.respond_to?(:modifier_form?) && node.parent.modifier_form?
               corrector.insert_after(node.parent, "\nend")
 
-              range = range_with_surrounding_space(node.loc.expression, side: :right)
+              range = range_with_surrounding_space(node.source_range, side: :right)
             else
               range = range_by_whole_lines(node.source_range, include_final_newline: true)
             end
@@ -68,12 +81,18 @@ 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') ||
+            (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 need_to_require_pp?
+          processed_source.ast.each_descendant(:send).any? do |node|
+            pp_const?(node.receiver) || PRETTY_PRINT_METHODS.include?(node.method_name)
+          end
+        end
       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
@@ -57,18 +67,24 @@ module RuboCop
 
         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
 
+        # 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
+        # rubocop:enable Metrics/AbcSize
 
         private
 

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

@@ -141,7 +141,7 @@ module RuboCop
           expression = loc.expression
 
           if array_new?(variable)
-            expression = node.parent.loc.expression if node.parent.array_type?
+            expression = node.parent.source_range if node.parent.array_type?
             [expression, variable.source]
           elsif !variable.array_type?
             [expression, "[#{variable.source}]"]

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for string conversion in string interpolation,
+      # Checks for string conversion in string interpolation, `print`, `puts`, and `warn` arguments,
       # which is redundant.
       #
       # @example
@@ -11,18 +11,26 @@ module RuboCop
       #   # bad
       #
       #   "result is #{something.to_s}"
+      #   print something.to_s
+      #   puts something.to_s
+      #   warn something.to_s
       #
       # @example
       #
       #   # good
       #
       #   "result is #{something}"
+      #   print something
+      #   puts something
+      #   warn something
+      #
       class RedundantStringCoercion < Base
         include Interpolation
         extend AutoCorrector
 
-        MSG_DEFAULT = 'Redundant use of `Object#to_s` in interpolation.'
-        MSG_SELF = 'Use `self` instead of `Object#to_s` in interpolation.'
+        MSG_DEFAULT = 'Redundant use of `Object#to_s` in %<context>s.'
+        MSG_SELF = 'Use `self` instead of `Object#to_s` in %<context>s.'
+        RESTRICT_ON_SEND = %i[print puts warn].freeze
 
         # @!method to_s_without_args?(node)
         def_node_matcher :to_s_without_args?, '(send _ :to_s)'
@@ -32,18 +40,30 @@ module RuboCop
 
           return unless to_s_without_args?(final_node)
 
-          message = final_node.receiver ? MSG_DEFAULT : MSG_SELF
-
-          add_offense(final_node.loc.selector, message: message) do |corrector|
-            receiver = final_node.receiver
-            corrector.replace(
-              final_node,
-              if receiver
-                receiver.source
-              else
-                'self'
-              end
-            )
+          register_offense(final_node, 'interpolation')
+        end
+
+        def on_send(node)
+          return if node.receiver
+
+          node.each_child_node(:send) do |child|
+            next if !child.method?(:to_s) || child.arguments.any?
+
+            register_offense(child, "`#{node.method_name}`")
+          end
+        end
+
+        private
+
+        def register_offense(node, context)
+          receiver = node.receiver
+          template = receiver ? MSG_DEFAULT : MSG_SELF
+          message = format(template, context: context)
+
+          add_offense(node.loc.selector, message: message) do |corrector|
+            replacement = receiver ? receiver.source : 'self'
+
+            corrector.replace(node, replacement)
           end
         end
       end

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

@@ -72,7 +72,7 @@ module RuboCop
         end
 
         def with_index_range(send)
-          range_between(send.loc.selector.begin_pos, send.loc.expression.end_pos)
+          range_between(send.loc.selector.begin_pos, send.source_range.end_pos)
         end
       end
     end

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

@@ -71,7 +71,7 @@ module RuboCop
         end
 
         def with_object_range(send)
-          range_between(send.loc.selector.begin_pos, send.loc.expression.end_pos)
+          range_between(send.loc.selector.begin_pos, send.source_range.end_pos)
         end
       end
     end

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

@@ -41,7 +41,8 @@ module RuboCop
 
         def on_send(node)
           return if node.receiver
-          return unless node.parent.block_type? && node.parent.method?(:refine)
+          return unless (parent = node.parent)
+          return unless parent.block_type? && parent.method?(:refine)
 
           add_offense(node.loc.selector, message: format(MSG, current: node.method_name))
         end

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

@@ -17,13 +17,19 @@ module RuboCop
       #     do_something
       #   end
       class RegexpAsCondition < Base
+        include IgnoredNode
         extend AutoCorrector
 
         MSG = 'Do not use regexp literal as a condition. ' \
               'The regexp literal matches `$_` implicitly.'
 
         def on_match_current_line(node)
+          return if node.ancestors.none?(&:conditional?)
+          return if part_of_ignored_node?(node)
+
           add_offense(node) { |corrector| corrector.replace(node, "#{node.source} =~ $_") }
+
+          ignore_node(node)
         end
       end
     end

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

@@ -46,7 +46,9 @@ module RuboCop
         private
 
         def check_ternary(ternary, node)
-          return if node.method?(:[]) || !ternary.condition.operator_keyword?
+          if node.method?(:[]) || node.assignment_method? || !ternary.condition.operator_keyword?
+            return
+          end
 
           range = range_between(node.source_range.begin_pos, ternary.condition.source_range.end_pos)
 

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

@@ -50,7 +50,7 @@ module RuboCop
           return if invalid_exceptions.empty?
 
           add_offense(
-            node.loc.keyword.join(rescued.loc.expression),
+            node.loc.keyword.join(rescued.source_range),
             message: format(MSG, invalid_exceptions: invalid_exceptions.map(&:source).join(', '))
           ) do |corrector|
             autocorrect(corrector, node)
@@ -59,9 +59,9 @@ module RuboCop
 
         def autocorrect(corrector, node)
           rescued, _, _body = *node
-          range = Parser::Source::Range.new(node.loc.expression.source_buffer,
+          range = Parser::Source::Range.new(node.source_range.source_buffer,
                                             node.loc.keyword.end_pos,
-                                            rescued.loc.expression.end_pos)
+                                            rescued.source_range.end_pos)
 
           corrector.replace(range, correction(*rescued))
         end

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

@@ -82,16 +82,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/safe_navigation_consistency.rb

@@ -65,7 +65,7 @@ module RuboCop
         end
 
         def location(node, unsafe_method_call)
-          node.loc.expression.join(unsafe_method_call.loc.expression)
+          node.source_range.join(unsafe_method_call.source_range)
         end
 
         def top_conditional_ancestor(node)

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

@@ -53,7 +53,7 @@ module RuboCop
         private
 
         def autocorrect(comment)
-          FileUtils.chmod('+x', comment.loc.expression.source_buffer.name)
+          FileUtils.chmod('+x', comment.source_range.source_buffer.name)
         end
 
         def executable?(processed_source)

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

@@ -83,7 +83,7 @@ module RuboCop
 
         def offense_range(rescues)
           shadowing_rescue = find_shadowing_rescue(rescues)
-          expression = shadowing_rescue.loc.expression
+          expression = shadowing_rescue.source_range
           range_between(expression.begin_pos, expression.end_pos)
         end
 
@@ -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

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

@@ -32,25 +32,25 @@ module RuboCop
         # @!method struct_new(node)
         def_node_matcher :struct_new, <<~PATTERN
           (send
-            (const ${nil? cbase} :Struct) :new ...)
+            (const {nil? cbase} :Struct) :new ...)
         PATTERN
 
         def on_send(node)
-          return unless struct_new(node) do
-            node.arguments.each_with_index do |arg, index|
-              # Ignore if the first argument is a class name
-              next if index.zero? && arg.str_type?
+          return unless struct_new(node)
 
-              # Ignore if the argument is not a member name
-              next unless STRUCT_MEMBER_NAME_TYPES.include?(arg.type)
+          node.arguments.each_with_index do |arg, index|
+            # Ignore if the first argument is a class name
+            next if index.zero? && arg.str_type?
 
-              member_name = arg.value
+            # Ignore if the argument is not a member name
+            next unless STRUCT_MEMBER_NAME_TYPES.include?(arg.type)
 
-              next unless STRUCT_METHOD_NAMES.include?(member_name.to_sym)
+            member_name = arg.value
 
-              message = format(MSG, member_name: member_name.inspect, method_name: member_name.to_s)
-              add_offense(arg, message: message)
-            end
+            next unless STRUCT_METHOD_NAMES.include?(member_name.to_sym)
+
+            message = format(MSG, member_name: member_name.inspect, method_name: member_name.to_s)
+            add_offense(arg, message: message)
           end
         end
       end