rubocop 1.50.2 → 1.54.1

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

@@ -49,6 +49,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 +77,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_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/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/suppressed_exception.rb

@@ -117,7 +117,7 @@ module RuboCop
 
         def comment_between_rescue_and_end?(node)
           ancestor = node.each_ancestor(:kwbegin, :def, :defs, :block, :numblock).first
-          return unless ancestor
+          return false unless ancestor
 
           end_line = ancestor.loc.end.line
           processed_source[node.first_line...end_line].any? { |line| comment_line?(line) }

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

@@ -124,7 +124,7 @@ module RuboCop
           source == value ||
             # `Symbol#inspect` uses double quotes, but allow single-quoted
             # symbols to work as well.
-            source.tr("'", '"') == value
+            source.gsub('"', '\"').tr("'", '"') == value
         end
 
         def requires_quotes?(sym_node)

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

@@ -8,25 +8,39 @@ module RuboCop
       # always ignored. This is detected automatically since Ruby 2.7.
       #
       # @example
+      #   # bad
+      #   return 1
       #
-      #   # Detected since Ruby 2.7
-      #   return 1 # 1 is always ignored.
+      #   # good
+      #   return
       class TopLevelReturnWithArgument < Base
-        # This cop works by validating the ancestors of the return node. A
-        # top-level return node's ancestors should not be of block, def, or
-        # defs type.
+        extend AutoCorrector
 
         MSG = 'Top level return with argument detected.'
 
         def on_return(return_node)
-          add_offense(return_node) if return_node.arguments? && ancestors_valid?(return_node)
+          return unless top_level_return_with_any_argument?(return_node)
+
+          add_offense(return_node) do |corrector|
+            remove_arguments(corrector, return_node)
+          end
         end
 
         private
 
-        def ancestors_valid?(return_node)
-          prohibited_ancestors = return_node.each_ancestor(:block, :def, :defs)
-          prohibited_ancestors.none?
+        def top_level_return_with_any_argument?(return_node)
+          top_level_return?(return_node) && return_node.arguments?
+        end
+
+        def remove_arguments(corrector, return_node)
+          corrector.replace(return_node, 'return')
+        end
+
+        # This cop works by validating the ancestors of the return node. A
+        # top-level return node's ancestors should not be of block, def, or
+        # defs type.
+        def top_level_return?(return_node)
+          return_node.each_ancestor(:block, :def, :defs).none?
         end
       end
     end

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

@@ -13,6 +13,12 @@ module RuboCop
       # reassignments and properly handles varied cases such as branch, loop,
       # rescue, ensure, etc.
       #
+      # @safety
+      #   This cop's autocorrection is unsafe because removing assignment from
+      #   operator assignment can cause NameError if this assignment has been used to declare
+      #   local variable. For example, replacing `a ||= 1` to `a || 1` may cause
+      #   "undefined local variable or method `a' for main:Object (NameError)".
+      #
       # @example
       #
       #   # bad
@@ -31,6 +37,10 @@ module RuboCop
       #     do_something(some_var)
       #   end
       class UselessAssignment < Base
+        extend AutoCorrector
+
+        include RangeHelp
+
         MSG = 'Useless assignment to variable - `%<variable>s`.'
 
         def self.joining_forces
@@ -55,7 +65,9 @@ module RuboCop
                          assignment.node.loc.name
                        end
 
-            add_offense(location, message: message)
+            add_offense(location, message: message) do |corrector|
+              autocorrect(corrector, assignment)
+            end
           end
         end
 
@@ -119,6 +131,52 @@ module RuboCop
 
           node.receiver.nil? && !node.arguments?
         end
+
+        # rubocop:disable Metrics/AbcSize
+        def autocorrect(corrector, assignment)
+          if assignment.exception_assignment?
+            remove_exception_assignment_part(corrector, assignment.node)
+          elsif assignment.multiple_assignment? || assignment.rest_assignment? ||
+                assignment.for_assignment?
+            rename_variable_with_underscore(corrector, assignment.node)
+          elsif assignment.operator_assignment?
+            remove_trailing_character_from_operator(corrector, assignment.node)
+          elsif assignment.regexp_named_capture?
+            replace_named_capture_group_with_non_capturing_group(corrector, assignment.node,
+                                                                 assignment.variable.name)
+          else
+            remove_local_variable_assignment_part(corrector, assignment.node)
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        def remove_exception_assignment_part(corrector, node)
+          corrector.remove(
+            range_between(
+              (node.parent.children.first&.source_range || node.parent.location.keyword).end_pos,
+              node.source_range.end_pos
+            )
+          )
+        end
+
+        def rename_variable_with_underscore(corrector, node)
+          corrector.replace(node, '_')
+        end
+
+        def remove_trailing_character_from_operator(corrector, node)
+          corrector.remove(node.parent.location.operator.end.adjust(begin_pos: -1))
+        end
+
+        def replace_named_capture_group_with_non_capturing_group(corrector, node, variable_name)
+          corrector.replace(
+            node.children.first,
+            node.children.first.source.sub(/\(\?<#{variable_name}>/, '(?:')
+          )
+        end
+
+        def remove_local_variable_assignment_part(corrector, node)
+          corrector.replace(node, node.expression.source)
+        end
       end
     end
   end

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

@@ -41,6 +41,10 @@ module RuboCop
       #     do_something(some_array)
       #   end
       class Void < Base
+        extend AutoCorrector
+
+        include RangeHelp
+
         OP_MSG = 'Operator `%<op>s` used in void context.'
         VAR_MSG = 'Variable `%<var>s` used in void context.'
         LIT_MSG = 'Literal `%<lit>s` used in void context.'
@@ -100,35 +104,53 @@ module RuboCop
         def check_void_op(node)
           return unless node.send_type? && OPERATORS.include?(node.method_name)
 
-          add_offense(node.loc.selector, message: format(OP_MSG, op: node.method_name))
+          add_offense(node.loc.selector,
+                      message: format(OP_MSG, op: node.method_name)) do |corrector|
+            autocorrect_void_op(corrector, node)
+          end
         end
 
         def check_var(node)
           return unless node.variable? || node.const_type?
 
-          add_offense(node.loc.name, message: format(VAR_MSG, var: node.loc.name.source))
+          if node.const_type? && node.special_keyword?
+            add_offense(node, message: format(VAR_MSG, var: node.source)) do |corrector|
+              autocorrect_void_expression(corrector, node)
+            end
+          else
+            add_offense(node.loc.name,
+                        message: format(VAR_MSG, var: node.loc.name.source)) do |corrector|
+              autocorrect_void_expression(corrector, node)
+            end
+          end
         end
 
         def check_literal(node)
           return if !node.literal? || node.xstr_type? || node.range_type?
 
-          add_offense(node, message: format(LIT_MSG, lit: node.source))
+          add_offense(node, message: format(LIT_MSG, lit: node.source)) do |corrector|
+            autocorrect_void_expression(corrector, node)
+          end
         end
 
         def check_self(node)
           return unless node.self_type?
 
-          add_offense(node, message: SELF_MSG)
+          add_offense(node, message: SELF_MSG) do |corrector|
+            autocorrect_void_expression(corrector, node)
+          end
         end
 
         def check_void_expression(node)
           return unless node.defined_type? || node.lambda_or_proc?
 
-          add_offense(node, message: format(EXPRESSION_MSG, expression: node.source))
+          add_offense(node, message: format(EXPRESSION_MSG, expression: node.source)) do |corrector|
+            autocorrect_void_expression(corrector, node)
+          end
         end
 
         def check_nonmutating(node)
-          return unless node.respond_to?(:method_name)
+          return if !node.send_type? && !node.block_type? && !node.numblock_type?
 
           method_name = node.method_name
           return unless NONMUTATING_METHODS.include?(method_name)
@@ -139,7 +161,10 @@ module RuboCop
                          "#{method_name}!"
                        end
           add_offense(node,
-                      message: format(NONMUTATING_MSG, method: method_name, suggest: suggestion))
+                      message: format(NONMUTATING_MSG, method: method_name,
+                                                       suggest: suggestion)) do |corrector|
+            autocorrect_nonmutating_send(corrector, node, suggestion)
+          end
         end
 
         def in_void_context?(node)
@@ -149,6 +174,31 @@ module RuboCop
 
           VOID_CONTEXT_TYPES.include?(parent.type) && parent.void_context?
         end
+
+        def autocorrect_void_op(corrector, node)
+          if node.arguments.empty?
+            corrector.replace(node, node.receiver.source)
+          else
+            corrector.replace(
+              range_with_surrounding_space(range: node.loc.selector, side: :both,
+                                           newlines: false),
+              "\n"
+            )
+          end
+        end
+
+        def autocorrect_void_expression(corrector, node)
+          corrector.remove(range_with_surrounding_space(range: node.source_range, side: :left))
+        end
+
+        def autocorrect_nonmutating_send(corrector, node, suggestion)
+          send_node = if node.send_type?
+                        node
+                      else
+                        node.send_node
+                      end
+          corrector.replace(send_node.loc.selector, suggestion)
+        end
       end
     end
   end

data/lib/rubocop/cop/metrics/utils/abc_size_calculator.rb

@@ -117,8 +117,7 @@ module RuboCop
           end
 
           def capturing_variable?(name)
-            # TODO: Remove `Symbol#to_s` after supporting only Ruby >= 2.7.
-            name && !name.to_s.start_with?('_')
+            name && !name.start_with?('_')
           end
 
           def branch?(node)

data/lib/rubocop/cop/metrics/utils/code_length_calculator.rb

@@ -63,7 +63,7 @@ module RuboCop
             types
           end
 
-          def code_length(node)
+          def code_length(node) # rubocop:disable Metrics/MethodLength
             if classlike_node?(node)
               classlike_code_length(node)
             elsif heredoc_node?(node)
@@ -72,7 +72,14 @@ module RuboCop
               body = extract_body(node)
               return 0 unless body
 
-              body.source.each_line.count { |line| !irrelevant_line?(line) }
+              source =
+                if node_with_heredoc?(body)
+                  source_from_node_with_heredoc(body)
+                else
+                  body.source.lines
+                end
+
+              source.count { |line| !irrelevant_line?(line) }
             end
           end
 
@@ -175,6 +182,27 @@ module RuboCop
           def another_args?(node)
             node.call_type? && node.arguments.count > 1
           end
+
+          def node_with_heredoc?(node)
+            node.each_descendant(:str, :dstr).any? { |descendant| heredoc_node?(descendant) }
+          end
+
+          def source_from_node_with_heredoc(node)
+            last_line = -1
+            node.each_descendant do |descendant|
+              next unless descendant.source
+
+              descendant_last_line =
+                if heredoc_node?(descendant)
+                  descendant.loc.heredoc_end.line
+                else
+                  descendant.last_line
+                end
+
+              last_line = [last_line, descendant_last_line].max
+            end
+            @processed_source[(node.first_line - 1)..(last_line - 1)]
+          end
         end
       end
     end

data/lib/rubocop/cop/migration/department_name.rb

@@ -16,7 +16,7 @@ module RuboCop
         # The token that makes up a disable comment.
         # The allowed specification for comments after `# rubocop: disable` is
         # `DepartmentName/CopName` or` all`.
-        DISABLING_COPS_CONTENT_TOKEN = %r{[A-z]+/[A-z]+|all}.freeze
+        DISABLING_COPS_CONTENT_TOKEN = %r{[A-Za-z]+/[A-Za-z]+|all}.freeze
 
         def on_new_investigation
           processed_source.comments.each do |comment|
@@ -67,7 +67,7 @@ module RuboCop
         end
 
         def contain_unexpected_character_for_department_name?(name)
-          name.match?(%r{[^A-z/, ]})
+          name.match?(%r{[^A-Za-z/, ]})
         end
 
         def qualified_legacy_cop_name(cop_name)

data/lib/rubocop/cop/mixin/allowed_receivers.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module encapsulates the ability to allow certain receivers in a cop.
+    module AllowedReceivers
+      def allowed_receiver?(receiver)
+        receiver_name = receiver_name(receiver)
+
+        allowed_receivers.include?(receiver_name)
+      end
+
+      def receiver_name(receiver)
+        if receiver.receiver && !receiver.receiver.const_type?
+          return receiver_name(receiver.receiver)
+        end
+
+        if receiver.send_type?
+          if receiver.receiver
+            "#{receiver_name(receiver.receiver)}.#{receiver.method_name}"
+          else
+            receiver.method_name.to_s
+          end
+        else
+          receiver.source
+        end
+      end
+
+      def allowed_receivers
+        cop_config.fetch('AllowedReceivers', [])
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/comments_help.rb

@@ -25,7 +25,7 @@ module RuboCop
       def comments_contain_disables?(node, cop_name)
         disabled_ranges = processed_source.disabled_line_ranges[cop_name]
 
-        return unless disabled_ranges
+        return false unless disabled_ranges
 
         node_range = node.source_range.line...find_end_line(node)
 
@@ -62,12 +62,16 @@ module RuboCop
       # Returns the end line of a node, which might be a comment and not part of the AST
       # End line is considered either the line at which another node starts, or
       # the line at which the parent node ends.
-      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Lint/DuplicateBranch
       def find_end_line(node)
         if node.if_type? && node.else?
           node.loc.else.line
         elsif node.if_type? && node.ternary?
           node.else_branch.loc.line
+        elsif node.if_type? && node.elsif?
+          node.each_ancestor(:if).find(&:if?).loc.end.line
+        elsif node.block_type? || node.numblock_type?
+          node.loc.end.line
         elsif (next_sibling = node.right_sibling) && next_sibling.is_a?(AST::Node)
           next_sibling.loc.line
         elsif (parent = node.parent)
@@ -76,7 +80,7 @@ module RuboCop
           node.loc.end.line
         end
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Lint/DuplicateBranch
     end
   end
 end

data/lib/rubocop/cop/mixin/end_keyword_alignment.rb

@@ -67,7 +67,7 @@ module RuboCop
       end
 
       def variable_alignment?(whole_expression, rhs, end_alignment_style)
-        return if end_alignment_style == :keyword
+        return false if end_alignment_style == :keyword
 
         !line_break_before_keyword?(whole_expression, rhs)
       end