rubocop 1.71.1 → 1.92.0

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

@@ -39,6 +39,9 @@ module RuboCop
       #   array.reject { |x| x =~ /regexp/ }
       #   array.reject { |x| /regexp/ =~ x }
       #
+      #   # bad (negative form)
+      #   array.reject { |x| !x.match? /regexp/ }
+      #
       #   # good
       #   array.grep(regexp)
       #   array.grep_v(regexp)
@@ -48,17 +51,19 @@ module RuboCop
 
         MSG = 'Prefer `%<replacement>s` to `%<original_method>s` with a regexp match.'
         RESTRICT_ON_SEND = %i[select filter find_all reject].freeze
-        REPLACEMENTS = { select: 'grep', filter: 'grep', find_all: 'grep', reject: 'grep_v' }.freeze
-        OPPOSITE_REPLACEMENTS = {
-          select: 'grep_v', filter: 'grep_v', find_all: 'grep_v', reject: 'grep'
-        }.freeze
-        REGEXP_METHODS = %i[match? =~ !~].to_set.freeze
+        SELECT_METHODS = %i[select filter find_all].freeze
+        REGEXP_METHODS = %i[match? =~].to_set.freeze
+        REGEXP_METHODS_NEGATED = %i[!~].to_set.freeze
 
         # @!method regexp_match?(node)
         def_node_matcher :regexp_match?, <<~PATTERN
           {
-            (block call (args (arg $_)) ${(send _ %REGEXP_METHODS _) match-with-lvasgn})
-            (numblock call $1 ${(send _ %REGEXP_METHODS _) match-with-lvasgn})
+            (block call (args (arg $_)) ${(send _ %REGEXP_METHODS _) (send _ %REGEXP_METHODS_NEGATED _) match-with-lvasgn})
+            (block call (args (arg $_)) ${(send (send _ %REGEXP_METHODS _) :!) (send (begin (send _ %REGEXP_METHODS _)) :!) (send match-with-lvasgn :!) (send (begin match-with-lvasgn) :!)})
+            (numblock call $1 ${(send _ %REGEXP_METHODS _) (send _ %REGEXP_METHODS_NEGATED _) match-with-lvasgn})
+            (numblock call $1 ${(send (send _ %REGEXP_METHODS _) :!) (send (begin (send _ %REGEXP_METHODS _)) :!) (send match-with-lvasgn :!) (send (begin match-with-lvasgn) :!)})
+            (itblock call $_ ${(send _ %REGEXP_METHODS _) (send _ %REGEXP_METHODS_NEGATED _) match-with-lvasgn})
+            (itblock call $_ ${(send (send _ %REGEXP_METHODS _) :!) (send (begin (send _ %REGEXP_METHODS _)) :!) (send match-with-lvasgn :!) (send (begin match-with-lvasgn) :!)})
           }
         PATTERN
 
@@ -83,10 +88,16 @@ module RuboCop
             (send (lvar %1) ...)
             (send ... (lvar %1))
             (match-with-lvasgn regexp (lvar %1))
+            (send (send (lvar %1) ...) :!)
+            (send (send ... (lvar %1)) :!)
+            (send (match-with-lvasgn regexp (lvar %1)) :!)
+            (send (begin (send (lvar %1) ...)) :!)
+            (send (begin (send ... (lvar %1))) :!)
+            (send (begin (match-with-lvasgn regexp (lvar %1))) :!)
           }
         PATTERN
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_send(node)
           return if target_ruby_version < 2.6 && node.method?(:filter)
           return unless (block_node = node.block_node)
@@ -96,13 +107,12 @@ module RuboCop
           return if match_predicate_without_receiver?(regexp_method_send_node)
 
           replacement = replacement(regexp_method_send_node, node)
-          return if target_ruby_version <= 2.2 && replacement == 'grep_v'
+          return if target_ruby_version <= 2.2 && replacement.include?('grep_v')
 
           regexp = find_regexp(regexp_method_send_node, block_node)
 
           register_offense(node, block_node, regexp, replacement)
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         alias on_csend on_send
 
         private
@@ -114,11 +124,14 @@ module RuboCop
         end
 
         def replacement(regexp_method_send_node, node)
-          opposite = opposite?(regexp_method_send_node)
-
+          negated = negated?(regexp_method_send_node)
           method_name = node.method_name
 
-          opposite ? OPPOSITE_REPLACEMENTS[method_name] : REPLACEMENTS[method_name]
+          if SELECT_METHODS.include?(method_name)
+            negated ? 'grep_v' : 'grep'
+          else # reject
+            negated ? 'grep' : 'grep_v'
+          end
         end
 
         def register_offense(node, block_node, regexp, replacement)
@@ -137,28 +150,47 @@ module RuboCop
           return unless (block_arg_name, regexp_method_send_node = regexp_match?(block_node))
 
           block_arg_name = :"_#{block_arg_name}" if block_node.numblock_type?
+          block_arg_name = :it if block_node.type?(:itblock)
+
           return unless calls_lvar?(regexp_method_send_node, block_arg_name)
 
           regexp_method_send_node
         end
 
-        def opposite?(regexp_method_send_node)
-          regexp_method_send_node.send_type? && regexp_method_send_node.method?(:!~)
+        def negated?(regexp_method_send_node)
+          return true if regexp_method_send_node.send_type? && regexp_method_send_node.method?(:!)
+
+          inner = unwrap_negation(regexp_method_send_node)
+          inner.send_type? && inner.method?(:!~)
+        end
+
+        def unwrap_negation(node)
+          if node.send_type? && node.method?(:!)
+            receiver = node.receiver
+            receiver = receiver.children.first if receiver.begin_type?
+            receiver
+          else
+            node
+          end
         end
 
         def find_regexp(node, block)
-          return node.child_nodes.first if node.match_with_lvasgn_type?
+          inner = unwrap_negation(node)
+
+          return inner.child_nodes.first if inner.match_with_lvasgn_type?
 
-          if node.receiver.lvar_type? &&
-             (block.numblock_type? || node.receiver.source == block.first_argument.source)
-            node.first_argument
-          elsif node.first_argument.lvar_type?
-            node.receiver
+          if inner.receiver.lvar_type? &&
+             (block.type?(:numblock, :itblock) ||
+              inner.receiver.source == block.first_argument.source)
+            inner.first_argument
+          elsif inner.first_argument&.lvar_type?
+            inner.receiver
           end
         end
 
         def match_predicate_without_receiver?(node)
-          node.send_type? && node.method?(:match?) && node.receiver.nil?
+          inner = unwrap_negation(node)
+          inner.send_type? && inner.method?(:match?) && inner.receiver.nil?
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # Enforces the use the shorthand for self-assignment.
+      # Enforces the use of the shorthand for self-assignment.
       #
       # @example
       #
@@ -37,15 +37,20 @@ module RuboCop
         private
 
         def check(node, var_type)
-          return unless (rhs = node.expression)
+          return unless (rhs = unparenthesized(node.expression))
 
           if rhs.send_type? && rhs.arguments.one?
             check_send_node(node, rhs, node.name, var_type)
-          elsif rhs.operator_keyword?
+          elsif rhs.operator_keyword? && rhs.logical_operator?
             check_boolean_node(node, rhs, node.name, var_type)
           end
         end
 
+        def unparenthesized(node)
+          node = node.children.first while node&.begin_type? && node.children.one?
+          node
+        end
+
         def check_send_node(node, rhs, var_name, var_type)
           return unless OPS.include?(rhs.method_name)
 
@@ -68,26 +73,18 @@ module RuboCop
         end
 
         def autocorrect(corrector, node)
-          rhs = node.expression
+          rhs = unparenthesized(node.expression)
 
           if rhs.send_type?
-            autocorrect_send_node(corrector, node, rhs)
+            apply_autocorrect(corrector, node, rhs.method_name, rhs.first_argument)
           elsif rhs.operator_keyword?
-            autocorrect_boolean_node(corrector, node, rhs)
+            apply_autocorrect(corrector, node, rhs.loc.operator.source, rhs.rhs)
           end
         end
 
-        def autocorrect_send_node(corrector, node, rhs)
-          apply_autocorrect(corrector, node, rhs, rhs.method_name, rhs.first_argument)
-        end
-
-        def autocorrect_boolean_node(corrector, node, rhs)
-          apply_autocorrect(corrector, node, rhs, rhs.loc.operator.source, rhs.rhs)
-        end
-
-        def apply_autocorrect(corrector, node, rhs, operator, new_rhs)
+        def apply_autocorrect(corrector, node, operator, new_rhs)
           corrector.insert_before(node.loc.operator, operator)
-          corrector.replace(rhs, new_rhs.source)
+          corrector.replace(node.expression, new_rhs.source)
         end
       end
     end

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

@@ -5,6 +5,8 @@ module RuboCop
     module Style
       # Checks for multiple expressions placed on the same line.
       # It also checks for lines terminated with a semicolon.
+      # In idiomatic Ruby, each expression should be on its own line
+      # for readability.
       #
       # This cop has `AllowAsExpressionSeparator` configuration option.
       # It allows `;` to separate several expressions on the same line.
@@ -69,10 +71,11 @@ module RuboCop
 
         def each_semicolon
           tokens_for_lines.each do |line, tokens|
-            semicolon_pos = semicolon_position(tokens)
+            next unless (semicolon_pos = semicolon_position(tokens))
+
             after_expr_pos = semicolon_pos == -1 ? -2 : semicolon_pos
 
-            yield line, tokens[semicolon_pos].column, tokens[after_expr_pos] if semicolon_pos
+            yield line, tokens[semicolon_pos].column, tokens[after_expr_pos]
           end
         end
 
@@ -80,7 +83,7 @@ module RuboCop
           processed_source.tokens.group_by(&:line)
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def semicolon_position(tokens)
           if tokens.last.semicolon?
             -1
@@ -97,7 +100,6 @@ module RuboCop
             -4
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def exist_semicolon_before_right_curly_brace?(tokens)
           tokens[-2]&.right_curly_brace? && tokens[-3]&.semicolon?
@@ -124,14 +126,16 @@ module RuboCop
 
           add_offense(range) do |corrector|
             if after_expression
-              corrector.replace(range, "\n")
+              replace_semicolon_with_line_break(corrector, range)
             else
               # Prevents becoming one range instance with subsequent line when endless range
               # without parentheses.
               # See: https://github.com/rubocop/rubocop/issues/10791
               if token_before_semicolon&.regexp_dots?
-                range_node = find_range_node(token_before_semicolon)
-                corrector.wrap(range_node, '(', ')') if range_node
+                node = find_node(range_nodes, token_before_semicolon)
+                corrector.wrap(node, '(', ')') if node
+              elsif token_before_semicolon&.type == :tLABEL
+                parenthesize_arguments(corrector, value_omission_hash(token_before_semicolon))
               end
 
               corrector.remove(range)
@@ -139,6 +143,35 @@ module RuboCop
           end
         end
 
+        def replace_semicolon_with_line_break(corrector, range)
+          # Replacing the semicolon with a newline would move the rest of the
+          # line into the body of a heredoc opened earlier on that line.
+          return if heredoc_opened_before_semicolon?(range)
+
+          corrector.replace(range, "\n")
+        end
+
+        def heredoc_opened_before_semicolon?(semicolon_range)
+          processed_source.ast.each_descendant(:any_str).select(&:heredoc?).any? do |heredoc|
+            heredoc.first_line == semicolon_range.line &&
+              heredoc.source_range.end_pos <= semicolon_range.begin_pos
+          end
+        end
+
+        def value_omission_hash(token_before_semicolon)
+          find_node(value_omission_pair_nodes, token_before_semicolon)&.parent
+        end
+
+        def parenthesize_arguments(corrector, hash_node)
+          return unless hash_node
+
+          call = hash_node.parent
+          before_arguments = args_begin(call).begin.join(call.first_argument.source_range.begin)
+
+          corrector.replace(before_arguments, '(')
+          corrector.insert_after(call.last_argument, ')')
+        end
+
         def expressions_per_line(exprs)
           # create a map matching lines to the number of expressions on them
           exprs_lines = exprs.map(&:last_line)
@@ -146,16 +179,16 @@ module RuboCop
         end
 
         def find_semicolon_positions(line)
-          # Scan for all the semicolons on the line
-          semicolons = processed_source[line - 1].enum_for(:scan, ';')
-          semicolons.each do
-            yield Regexp.last_match.begin(0)
+          # Scan for all the semicolon tokens on the line. Iterating tokens rather
+          # than the raw source skips `;` characters inside string/regexp literals.
+          processed_source.tokens.each do |token|
+            yield token.column if token.line == line && token.semicolon?
           end
         end
 
-        def find_range_node(token_before_semicolon)
-          range_nodes.detect do |range_node|
-            range_node.source_range.contains?(token_before_semicolon.pos)
+        def find_node(nodes, token_before_semicolon)
+          nodes.detect do |node|
+            node.source_range.overlaps?(token_before_semicolon.pos)
           end
         end
 
@@ -166,6 +199,15 @@ module RuboCop
           @range_nodes = ast.range_type? ? [ast] : []
           @range_nodes.concat(ast.each_descendant(:range).to_a)
         end
+
+        def value_omission_pair_nodes
+          if instance_variable_defined?(:@value_omission_pair_nodes)
+            return @value_omission_pair_nodes
+          end
+
+          ast = processed_source.ast
+          @value_omission_pair_nodes = ast.each_descendant(:pair).to_a.select(&:value_omission?)
+        end
       end
     end
   end

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

@@ -33,7 +33,7 @@ module RuboCop
 
         MSG = 'Name `%<method>s` block params `|%<params>s|`.'
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler -- checks block parameter names
           return unless node.single_line?
 
           return unless eligible_method?(node)
@@ -89,7 +89,7 @@ module RuboCop
         end
 
         def method_names
-          methods.map { |method| method_name(method).to_sym }
+          @method_names ||= methods.map { |method| method_name(method).to_sym }.freeze
         end
 
         def method_name(method)

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

@@ -36,31 +36,45 @@ module RuboCop
 
         MSG = 'Prefer multiline `do`...`end` block.'
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize
         def on_block(node)
-          return if !node.single_line? || node.braces?
+          return if node.multiline? || node.braces?
           return if single_line_blocks_preferred? && suitable_as_single_line?(node)
 
           add_offense(node) do |corrector|
             corrector.insert_after(do_line(node), "\n")
 
-            node_body = node.body
-
-            if node_body.respond_to?(:heredoc?) && node_body.heredoc?
+            if (heredoc = trailing_heredoc(node.body))
+              # The heredoc body extends past the `end` on the source, so the
+              # `end` has to be moved after it rather than before, which would
+              # otherwise move it into the heredoc body and break the syntax.
               corrector.remove(node.loc.end)
-              corrector.insert_after(node_body.loc.heredoc_end, "\nend")
+              corrector.insert_after(heredoc.loc.heredoc_end, "\nend")
             else
               corrector.insert_before(node.loc.end, "\n")
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
+        # Returns the heredoc opened on the block's line whose body extends the
+        # furthest down, whether it is the block body itself or nested within it.
+        def trailing_heredoc(node_body)
+          return unless node_body
+
+          heredocs = [node_body, *node_body.each_descendant].select do |node|
+            node.respond_to?(:heredoc?) && node.heredoc?
+          end
+
+          heredocs.max_by { |heredoc| heredoc.loc.heredoc_end.line }
+        end
+
         def do_line(node)
-          if node.numblock_type? || node.arguments.children.empty? || node.send_node.lambda_literal?
+          if node.type?(:numblock, :itblock) ||
+             node.arguments.children.empty? || node.send_node.lambda_literal?
             node.loc.begin
           else
             node.arguments

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

@@ -4,13 +4,15 @@ module RuboCop
   module Cop
     module Style
       # Checks for single-line method definitions that contain a body.
-      # It will accept single-line methods with no body.
+      # Single-line methods with a body are harder to read and debug
+      # than their multi-line equivalents. It will accept single-line
+      # methods with no body.
       #
       # Endless methods added in Ruby 3.0 are also accepted by this cop.
       #
-      # If `Style/EndlessMethod` is enabled with `EnforcedStyle: allow_single_line` or
-      # `allow_always`, single-line methods will be autocorrected to endless
-      # methods if there is only one statement in the body.
+      # If `Style/EndlessMethod` is enabled with `EnforcedStyle: allow_single_line`, `allow_always`,
+      # `require_single_line`, or `require_always`, single-line methods will be autocorrected
+      # to endless methods if there is only one statement in the body.
       #
       # @example
       #   # bad
@@ -33,6 +35,7 @@ module RuboCop
       #
       class SingleLineMethods < Base
         include Alignment
+        include EndlessMethodBodyHelp
         extend AutoCorrector
 
         MSG = 'Avoid single-line method definitions.'
@@ -65,10 +68,14 @@ module RuboCop
           return false if target_ruby_version < 3.0
           return false if disallow_endless_method_style?
           return false unless body_node
-          return false if body_node.parent.assignment_method? ||
-                          NOT_SUPPORTED_ENDLESS_METHOD_BODY_TYPES.include?(body_node.type)
+          return false if body_node.parent.assignment_method?
 
-          !body_node.type?(:begin, :kwbegin)
+          !unsupported_endless_method_body?(body_node) && endless_method_body?(body_node)
+        end
+
+        def unsupported_endless_method_body?(body_node)
+          body_node.basic_conditional? ||
+            NOT_SUPPORTED_ENDLESS_METHOD_BODY_TYPES.include?(body_node.type)
         end
 
         def correct_to_multiline(corrector, node)
@@ -86,10 +93,10 @@ module RuboCop
         end
 
         def correct_to_endless(corrector, node)
-          self_receiver = node.self_receiver? ? 'self.' : ''
-          arguments = node.arguments.any? ? node.arguments.source : '()'
+          receiver = "#{node.receiver.source}." if node.receiver
           body_source = method_body_source(node.body)
-          replacement = "def #{self_receiver}#{node.method_name}#{arguments} = #{body_source}"
+          arguments = endless_arguments(node)
+          replacement = "def #{receiver}#{node.method_name}#{arguments} = #{body_source}"
 
           corrector.replace(node, replacement)
         end
@@ -130,7 +137,17 @@ module RuboCop
         end
 
         def require_parentheses?(method_body)
-          method_body.send_type? && !method_body.arguments.empty? && !method_body.comparison_method?
+          return false unless method_body.send_type?
+          return false if method_body.arithmetic_operation?
+
+          !method_body.arguments.empty? && !method_body.comparison_method?
+        end
+
+        def endless_arguments(node)
+          arguments = node.arguments
+          return '()' if arguments.none?
+
+          arguments.loc.begin ? arguments.source : "(#{arguments.source})"
         end
 
         def disallow_endless_method_style?