rubocop 1.50.2 → 1.52.0

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,31 +104,43 @@ 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))
+          add_offense(node.loc.name,
+                      message: format(VAR_MSG, var: node.loc.name.source)) do |corrector|
+            autocorrect_void_var(corrector, node)
+          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_literal(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_self(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)
@@ -139,7 +155,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 +168,43 @@ 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_var(corrector, node)
+          corrector.remove(range_with_surrounding_space(range: node.loc.name, side: :left))
+        end
+
+        def autocorrect_void_literal(corrector, node)
+          corrector.remove(range_with_surrounding_space(range: node.source_range, side: :left))
+        end
+
+        def autocorrect_void_self(corrector, node)
+          corrector.remove(range_with_surrounding_space(range: node.source_range, side: :left))
+        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/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

@@ -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/space_after_punctuation.rb

@@ -36,7 +36,7 @@ module RuboCop
       end
 
       def allowed_type?(token)
-        %i[tRPAREN tRBRACK tPIPE].include?(token.type)
+        %i[tRPAREN tRBRACK tPIPE tSTRING_DEND].include?(token.type)
       end
 
       def space_forbidden_before_rcurly?

data/lib/rubocop/cop/naming/constant_name.rb

@@ -76,7 +76,7 @@ module RuboCop
         end
 
         def contains_constant?(node)
-          node.branches.any?(&:const_type?)
+          node.branches.compact.any?(&:const_type?)
         end
       end
     end

data/lib/rubocop/cop/naming/memoized_instance_variable_name.rb

@@ -17,7 +17,8 @@ module RuboCop
       # @safety
       #   This cop relies on the pattern `@instance_var ||= ...`,
       #   but this is sometimes used for other purposes than memoization
-      #   so this cop is considered unsafe.
+      #   so this cop is considered unsafe. Also, its autocorrection is unsafe
+      #   because it may conflict with instance variable names already in use.
       #
       # @example EnforcedStyleForLeadingUnderscores: disallowed (default)
       #   # bad
@@ -145,6 +146,8 @@ module RuboCop
       #     @_foo ||= calculate_expensive_thing
       #   end
       class MemoizedInstanceVariableName < Base
+        extend AutoCorrector
+
         include ConfigurableEnforcedStyle
 
         MSG = 'Memoized variable `%<var>s` does not match ' \
@@ -163,6 +166,7 @@ module RuboCop
         PATTERN
 
         # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/MethodLength
         def on_or_asgn(node)
           lhs, _value = *node
           return unless lhs.ivasgn_type?
@@ -175,14 +179,18 @@ module RuboCop
 
           return if matches?(method_name, lhs)
 
+          suggested_var = suggested_var(method_name)
           msg = format(
             message(lhs.children.first.to_s),
             var: lhs.children.first.to_s,
-            suggested_var: suggested_var(method_name),
+            suggested_var: suggested_var,
             method: method_name
           )
-          add_offense(lhs, message: msg)
+          add_offense(lhs, message: msg) do |corrector|
+            corrector.replace(lhs.loc.name, "@#{suggested_var}")
+          end
         end
+        # rubocop:enable Metrics/MethodLength
         # rubocop:enable Metrics/AbcSize
 
         # @!method defined_memoized?(node, ivar)
@@ -205,15 +213,22 @@ module RuboCop
           defined_memoized?(method_node.body, var_name) do |defined_ivar, return_ivar, ivar_assign|
             return if matches?(method_name, ivar_assign)
 
+            suggested_var = suggested_var(method_name)
             msg = format(
               message(var_name.to_s),
               var: var_name.to_s,
-              suggested_var: suggested_var(method_name),
+              suggested_var: suggested_var,
               method: method_name
             )
-            add_offense(defined_ivar, message: msg)
-            add_offense(return_ivar, message: msg)
-            add_offense(ivar_assign.loc.name, message: msg)
+            add_offense(defined_ivar, message: msg) do |corrector|
+              corrector.replace(defined_ivar, "@#{suggested_var}")
+            end
+            add_offense(return_ivar, message: msg) do |corrector|
+              corrector.replace(return_ivar, "@#{suggested_var}")
+            end
+            add_offense(ivar_assign.loc.name, message: msg) do |corrector|
+              corrector.replace(ivar_assign.loc.name, "@#{suggested_var}")
+            end
           end
         end
         # rubocop:enable Metrics/AbcSize, Metrics/MethodLength

data/lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb

@@ -82,9 +82,7 @@ module RuboCop
           message = message(node)
 
           add_offense(range, message: message) do |corrector|
-            corrector.replace(range, preferred_name)
-
-            correct_node(corrector, node.body, offending_name, preferred_name)
+            autocorrect(corrector, node, range, offending_name, preferred_name)
           end
         end
 
@@ -95,6 +93,16 @@ module RuboCop
           variable.source_range
         end
 
+        def autocorrect(corrector, node, range, offending_name, preferred_name)
+          corrector.replace(range, preferred_name)
+          correct_node(corrector, node.body, offending_name, preferred_name)
+          return unless (kwbegin_node = node.parent.each_ancestor(:kwbegin).first)
+
+          kwbegin_node.right_siblings.each do |child_node|
+            correct_node(corrector, child_node, offending_name, preferred_name)
+          end
+        end
+
         def variable_name_matches?(node, name)
           if node.masgn_type?
             node.each_descendant(:lvasgn).any? do |lvasgn_node|

data/lib/rubocop/cop/naming/variable_name.rb

@@ -20,9 +20,14 @@ module RuboCop
       #   # good
       #   fooBar = 1
       #
+      # @example AllowedIdentifiers: ['fooBar']
+      #   # good (with EnforcedStyle: snake_case)
+      #   fooBar = 1
+      #
       # @example AllowedPatterns: ['_v\d+\z']
-      #   # good
+      #   # good (with EnforcedStyle: camelCase)
       #   :release_v1
+      #
       class VariableName < Base
         include AllowedIdentifiers
         include ConfigurableNaming

data/lib/rubocop/cop/style/accessor_grouping.rb

@@ -92,6 +92,7 @@ module RuboCop
           comment_line?(processed_source[node.first_line - 2])
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def groupable_accessor?(node)
           return true unless (previous_expression = node.left_siblings.last)
 
@@ -104,8 +105,11 @@ module RuboCop
 
           return true unless previous_expression.send_type?
 
-          previous_expression.attribute_accessor? || previous_expression.access_modifier?
+          previous_expression.attribute_accessor? ||
+            previous_expression.access_modifier? ||
+            node.first_line - previous_expression.last_line > 1 # there is a space between nodes
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def class_send_elements(class_node)
           class_def = class_node.body

data/lib/rubocop/cop/style/attr.rb

@@ -24,7 +24,7 @@ module RuboCop
         def on_send(node)
           return unless node.command?(:attr) && node.arguments?
           # check only for method definitions in class/module body
-          return if node.parent && !node.parent.class_type? && !class_eval?(node.parent)
+          return if allowed_context?(node)
 
           message = message(node)
           add_offense(node.loc.selector, message: message) do |corrector|
@@ -34,6 +34,16 @@ module RuboCop
 
         private
 
+        def allowed_context?(node)
+          return false unless (class_node = node.each_ancestor(:class, :block).first)
+
+          (!class_node.class_type? && !class_eval?(class_node)) || define_attr_method?(class_node)
+        end
+
+        def define_attr_method?(node)
+          node.each_descendant(:def).any? { |def_node| def_node.method?(:attr) }
+        end
+
         def autocorrect(corrector, node)
           attr_name, setter = *node.arguments
 

data/lib/rubocop/cop/style/class_and_module_children.rb

@@ -139,7 +139,7 @@ module RuboCop
         end
 
         def check_style(node, body)
-          return if node.identifier.children[0]&.cbase_type?
+          return if node.identifier.namespace&.cbase_type?
 
           if style == :nested
             check_nested_style(node)

data/lib/rubocop/cop/style/collection_compact.rb

@@ -9,8 +9,8 @@ module RuboCop
       # @safety
       #   It is unsafe by default because false positives may occur in the
       #   `nil` check of block arguments to the receiver object. Additionally,
-      #    we can't know the type of the receiver object for sure, which may
-      #    result in false positives as well.
+      #   we can't know the type of the receiver object for sure, which may
+      #   result in false positives as well.
       #
       #   For example, `[[1, 2], [3, nil]].reject { |first, second| second.nil? }`
       #   and `[[1, 2], [3, nil]].compact` are not compatible. This will work fine
@@ -19,7 +19,9 @@ module RuboCop
       # @example
       #   # bad
       #   array.reject(&:nil?)
+      #   array.delete_if(&:nil?)
       #   array.reject { |e| e.nil? }
+      #   array.delete_if { |e| e.nil? }
       #   array.select { |e| !e.nil? }
       #
       #   # good
@@ -33,20 +35,25 @@ module RuboCop
       #   # good
       #   hash.compact!
       #
+      # @example AllowedReceivers: ['params']
+      #   # good
+      #   params.reject(&:nil?)
+      #
       class CollectionCompact < Base
+        include AllowedReceivers
         include RangeHelp
         extend AutoCorrector
         extend TargetRubyVersion
 
         MSG = 'Use `%<good>s` instead of `%<bad>s`.'
-        RESTRICT_ON_SEND = %i[reject reject! select select!].freeze
+        RESTRICT_ON_SEND = %i[reject delete_if reject! select select!].freeze
         TO_ENUM_METHODS = %i[to_enum lazy].freeze
 
         minimum_target_ruby_version 2.4
 
         # @!method reject_method_with_block_pass?(node)
         def_node_matcher :reject_method_with_block_pass?, <<~PATTERN
-          (send !nil? {:reject :reject!}
+          (send !nil? {:reject :delete_if :reject!}
             (block_pass
               (sym :nil?)))
         PATTERN
@@ -55,7 +62,7 @@ module RuboCop
         def_node_matcher :reject_method?, <<~PATTERN
           (block
             (send
-              !nil? {:reject :reject!})
+              !nil? {:reject :delete_if :reject!})
             $(args ...)
             (send
               $(lvar _) :nil?))
@@ -74,7 +81,10 @@ module RuboCop
 
         def on_send(node)
           return unless (range = offense_range(node))
-          return if target_ruby_version <= 3.0 && to_enum_method?(node)
+          return if allowed_receiver?(node.receiver)
+          if (target_ruby_version <= 3.0 || node.method?(:delete_if)) && to_enum_method?(node)
+            return
+          end
 
           good = good_method_name(node)
           message = format(MSG, good: good, bad: range.source)

data/lib/rubocop/cop/style/colon_method_call.rb

@@ -3,8 +3,8 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for methods invoked via the :: operator instead
-      # of the . operator (like FileUtils::rmdir instead of FileUtils.rmdir).
+      # Checks for methods invoked via the `::` operator instead
+      # of the `.` operator (like `FileUtils::rmdir` instead of `FileUtils.rmdir`).
       #
       # @example
       #   # bad

data/lib/rubocop/cop/style/combinable_loops.rb

@@ -57,38 +57,58 @@ module RuboCop
       #   end
       #
       class CombinableLoops < Base
+        extend AutoCorrector
+
+        include RangeHelp
+
         MSG = 'Combine this loop with the previous loop.'
 
         def on_block(node)
           return unless node.parent&.begin_type?
           return unless collection_looping_method?(node)
+          return unless same_collection_looping_block?(node, node.left_sibling)
 
-          add_offense(node) if same_collection_looping?(node, node.left_sibling)
+          add_offense(node) do |corrector|
+            combine_with_left_sibling(corrector, node)
+          end
         end
 
         alias on_numblock on_block
 
         def on_for(node)
           return unless node.parent&.begin_type?
+          return unless same_collection_looping_for?(node, node.left_sibling)
 
-          sibling = node.left_sibling
-          add_offense(node) if sibling&.for_type? && node.collection == sibling.collection
+          add_offense(node) do |corrector|
+            combine_with_left_sibling(corrector, node)
+          end
         end
 
         private
 
         def collection_looping_method?(node)
-          # TODO: Remove `Symbol#to_s` after supporting only Ruby >= 2.7.
-          method_name = node.method_name.to_s
+          method_name = node.method_name
           method_name.start_with?('each') || method_name.end_with?('_each')
         end
 
-        def same_collection_looping?(node, sibling)
+        def same_collection_looping_block?(node, sibling)
           (sibling&.block_type? || sibling&.numblock_type?) &&
             sibling.send_node.method?(node.method_name) &&
             sibling.receiver == node.receiver &&
             sibling.send_node.arguments == node.send_node.arguments
         end
+
+        def same_collection_looping_for?(node, sibling)
+          sibling&.for_type? && node.collection == sibling.collection
+        end
+
+        def combine_with_left_sibling(corrector, node)
+          corrector.replace(
+            node.left_sibling.body,
+            "#{node.left_sibling.body.source}\n#{node.body.source}"
+          )
+          corrector.remove(range_with_surrounding_space(range: node.source_range, side: :left))
+        end
       end
     end
   end

data/lib/rubocop/cop/style/conditional_assignment.rb

@@ -350,7 +350,7 @@ module RuboCop
         end
 
         def ternary_condition?(node)
-          [node, node.children.first].any? { |n| n.if_type? && n.ternary? }
+          [node, node.children.first].compact.any? { |n| n.if_type? && n.ternary? }
         end
 
         def lhs_all_match?(branches)
@@ -386,7 +386,7 @@ module RuboCop
         def allowed_statements?(branches)
           return false unless branches.all?
 
-          statements = branches.map { |branch| tail(branch) }.compact
+          statements = branches.filter_map { |branch| tail(branch) }
 
           lhs_all_match?(statements) && statements.none?(&:masgn_type?) &&
             assignment_types_match?(*statements)

data/lib/rubocop/cop/style/copyright.rb

@@ -8,8 +8,11 @@ module RuboCop
       # The default regexp for an acceptable copyright notice can be found in
       # config/default.yml. The default can be changed as follows:
       #
-      #  Style/Copyright:
-      #    Notice: '^Copyright (\(c\) )?2\d{3} Acme Inc'
+      # [source,yaml]
+      # ----
+      # Style/Copyright:
+      #   Notice: '^Copyright (\(c\) )?2\d{3} Acme Inc'
+      # ----
       #
       # This regex string is treated as an unanchored regex. For each file
       # that RuboCop scans, a comment that matches this regex must be found or

data/lib/rubocop/cop/style/documentation.rb

@@ -10,7 +10,7 @@ module RuboCop
       # declarations.
       #
       # The documentation requirement is annulled if the class or module has
-      # a "#:nodoc:" comment next to it. Likewise, "#:nodoc: all" does the
+      # a `#:nodoc:` comment next to it. Likewise, `#:nodoc: all` does the
       # same for all its children.
       #
       # @example

data/lib/rubocop/cop/style/eval_with_location.rb

@@ -57,7 +57,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Pass `__FILE__` and `__LINE__` to `%<method_name>s`.'
-        MSG_EVAL = 'Pass a binding, `__FILE__` and `__LINE__` to `eval`.'
+        MSG_EVAL = 'Pass a binding, `__FILE__`, and `__LINE__` to `eval`.'
         MSG_INCORRECT_FILE = 'Incorrect file for `%<method_name>s`; ' \
                              'use `%<expected>s` instead of `%<actual>s`.'
         MSG_INCORRECT_LINE = 'Incorrect line number for `%<method_name>s`; ' \
@@ -210,7 +210,7 @@ module RuboCop
         def add_offense_for_missing_line(node, code)
           register_offense(node) do |corrector|
             line_str = missing_line(node, code)
-            corrector.insert_after(node.source_range.end, ", #{line_str}")
+            corrector.insert_after(node.last_argument.source_range.end, ", #{line_str}")
           end
         end
 

data/lib/rubocop/cop/style/exact_regexp_match.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for exact regexp match inside Regexp literals.
+      #
+      # @example
+      #
+      #   # bad
+      #   string =~ /\Astring\z/
+      #   string === /\Astring\z/
+      #   string.match(/\Astring\z/)
+      #   string.match?(/\Astring\z/)
+      #
+      #   # good
+      #   string == 'string'
+      #
+      #   # bad
+      #   string !~ /\Astring\z/
+      #
+      #   # good
+      #   string != 'string'
+      #
+      class ExactRegexpMatch < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<prefer>s`.'
+        RESTRICT_ON_SEND = %i[=~ === !~ match match?].freeze
+
+        # @!method exact_regexp_match(node)
+        def_node_matcher :exact_regexp_match, <<~PATTERN
+          (send
+            _ {:=~ :=== :!~ :match :match?}
+            (regexp
+              (str $_)
+              (regopt)))
+        PATTERN
+
+        def on_send(node)
+          return unless (regexp = exact_regexp_match(node))
+
+          parsed_regexp = Regexp::Parser.parse(regexp)
+          return unless exact_match_pattern?(parsed_regexp)
+
+          prefer = "#{node.receiver.source} #{new_method(node)} '#{parsed_regexp[1].text}'"
+
+          add_offense(node, message: format(MSG, prefer: prefer)) do |corrector|
+            corrector.replace(node, prefer)
+          end
+        end
+
+        private
+
+        def exact_match_pattern?(parsed_regexp)
+          tokens = parsed_regexp.map(&:token)
+          return false unless tokens[0] == :bos && tokens[1] == :literal && tokens[2] == :eos
+
+          !parsed_regexp[1].quantifier
+        end
+
+        def new_method(node)
+          node.method?(:!~) ? '!=' : '=='
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/guard_clause.rb

@@ -187,6 +187,8 @@ module RuboCop
           if_branch = node.if_branch
           else_branch = node.else_branch
 
+          corrector.replace(node.loc.begin, "\n") if node.loc.begin&.is?('then')
+
           if if_branch&.send_type? && heredoc?(if_branch.last_argument)
             autocorrect_heredoc_argument(corrector, node, if_branch, else_branch, guard)
           elsif else_branch&.send_type? && heredoc?(else_branch.last_argument)