rubocop 1.44.1 → 1.78.0

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

@@ -17,7 +17,8 @@ module RuboCop
       # protected scope, you cannot send private messages this way.
       #
       # Note we allow uses of `self` with operators because it would be awkward
-      # otherwise.
+      # otherwise. Also allows the use of `self.it` without arguments in blocks,
+      # as in `0.times { self.it }`, following `Lint/ItWithoutArgumentsInBlock` cop.
       #
       # @example
       #
@@ -65,14 +66,15 @@ module RuboCop
         # Assignment of self.x
 
         def on_or_asgn(node)
-          lhs, _rhs = *node
-          allow_self(lhs)
+          allow_self(node.lhs)
+
+          lhs_name = node.lhs.lvasgn_type? ? node.lhs.name : node.lhs
+          add_lhs_to_local_variables_scopes(node.rhs, lhs_name)
         end
         alias on_and_asgn on_or_asgn
 
         def on_op_asgn(node)
-          lhs, _op, _rhs = *node
-          allow_self(lhs)
+          allow_self(node.lhs)
         end
 
         # Using self.x to distinguish from local variable x
@@ -91,13 +93,11 @@ module RuboCop
         end
 
         def on_masgn(node)
-          lhs, rhs = *node
-          add_masgn_lhs_variables(rhs, lhs)
+          add_masgn_lhs_variables(node.rhs, node.lhs)
         end
 
         def on_lvasgn(node)
-          lhs, rhs = *node
-          add_lhs_to_local_variables_scopes(rhs, lhs)
+          add_lhs_to_local_variables_scopes(node.rhs, node.lhs)
         end
 
         def on_in_pattern(node)
@@ -107,8 +107,8 @@ module RuboCop
         def on_send(node)
           return unless node.self_receiver? && regular_method_call?(node)
           return if node.parent&.mlhs_type?
-
           return if allowed_send_node?(node)
+          return if it_method_in_block?(node)
 
           add_offense(node.receiver) do |corrector|
             corrector.remove(node.receiver)
@@ -121,17 +121,16 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         def on_if(node)
           # Allow conditional nodes to use `self` in the condition if that variable
           # name is used in an `lvasgn` or `masgn` within the `if`.
-          node.child_nodes.each do |child_node|
-            lhs, _rhs = *child_node
-
-            if child_node.lvasgn_type?
-              add_lhs_to_local_variables_scopes(node.condition, lhs)
-            elsif child_node.masgn_type?
-              add_masgn_lhs_variables(node.condition, lhs)
+          node.each_descendant(:lvasgn, :masgn) do |descendant_node|
+            if descendant_node.lvasgn_type?
+              add_lhs_to_local_variables_scopes(node.condition, descendant_node.lhs)
+            else
+              add_masgn_lhs_variables(node.condition, descendant_node.lhs)
             end
           end
         end
@@ -155,6 +154,20 @@ module RuboCop
             KERNEL_METHODS.include?(node.method_name)
         end
 
+        # Respects `Lint/ItWithoutArgumentsInBlock` cop and the following Ruby 3.3's warning:
+        #
+        # $ ruby -e '0.times { begin; it; end }'
+        # -e:1: warning: `it` calls without arguments will refer to the first block param in
+        # Ruby 3.4; use it() or self.it
+        #
+        def it_method_in_block?(node)
+          return false unless node.method?(:it)
+          return false unless (block_node = node.each_ancestor(:block).first)
+          return false unless block_node.arguments.empty_and_without_delimiters?
+
+          node.arguments.empty? && !node.block_literal?
+        end
+
         def regular_method_call?(node)
           !(node.operator_method? ||
             KEYWORDS.include?(node.method_name) ||
@@ -166,9 +179,8 @@ module RuboCop
         def on_argument(node)
           if node.mlhs_type?
             on_args(node)
-          else
-            name, = *node
-            @local_variables_scopes[node] << name
+          elsif node.respond_to?(:name)
+            @local_variables_scopes[node] << node.name
           end
         end
 

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

@@ -21,12 +21,8 @@ module RuboCop
       #   args += foo
       #   hash.merge!(other)
       #
-      #   # bad
-      #   self.foo = foo.concat(ary)
-      #
       #   # good
       #   foo.concat(ary)
-      #   self.foo += ary
       #
       class RedundantSelfAssignment < Base
         include RangeHelp
@@ -49,19 +45,31 @@ module RuboCop
           gvasgn: :gvar
         }.freeze
 
+        # @!method redundant_self_assignment?
+        def_node_matcher :redundant_self_assignment?, <<~PATTERN
+          (call
+            %1 _
+            (call
+              (call
+                %1 %2) #method_returning_self?
+              ...))
+        PATTERN
+
+        # rubocop:disable Metrics/AbcSize
         def on_lvasgn(node)
-          lhs, rhs = *node
-          receiver, method_name, = *rhs
-          return unless receiver && method_returning_self?(method_name)
+          return unless (rhs = node.rhs)
+          return unless rhs.type?(:any_block, :call) && method_returning_self?(rhs.method_name)
+          return unless (receiver = rhs.receiver)
 
           receiver_type = ASSIGNMENT_TYPE_TO_RECEIVER_TYPE[node.type]
-          return unless receiver.type == receiver_type && receiver.children.first == lhs
+          return unless receiver.type == receiver_type && receiver.children.first == node.lhs
 
-          message = format(MSG, method_name: method_name)
+          message = format(MSG, method_name: rhs.method_name)
           add_offense(node.loc.operator, message: message) do |corrector|
             corrector.replace(node, rhs.source)
           end
         end
+        # rubocop:enable Metrics/AbcSize
         alias on_ivasgn on_lvasgn
         alias on_cvasgn on_lvasgn
         alias on_gvasgn on_lvasgn
@@ -75,6 +83,7 @@ module RuboCop
             corrector.remove(correction_range(node))
           end
         end
+        alias on_csend on_send
 
         private
 
@@ -82,31 +91,10 @@ module RuboCop
           METHODS_RETURNING_SELF.include?(method_name)
         end
 
-        # @!method redundant_self_assignment?(node, method_name)
-        def_node_matcher :redundant_self_assignment?, <<~PATTERN
-          (send
-            (self) _
-            (send
-              (send
-                {(self) nil?} %1) #method_returning_self?
-              ...))
-        PATTERN
-
-        # @!method redundant_nonself_assignment?(node, receiver, method_name)
-        def_node_matcher :redundant_nonself_assignment?, <<~PATTERN
-          (send
-            %1 _
-            (send
-              (send
-                %1 %2) #method_returning_self?
-              ...))
-        PATTERN
-
         def redundant_assignment?(node)
-          receiver_name = node.method_name.to_s[0...-1].to_sym
+          receiver_name = node.method_name.to_s.delete_suffix('=').to_sym
 
-          redundant_self_assignment?(node, receiver_name) ||
-            redundant_nonself_assignment?(node, node.receiver, receiver_name)
+          redundant_self_assignment?(node, node.receiver, receiver_name)
         end
 
         def correction_range(node)

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

@@ -23,7 +23,6 @@ module RuboCop
       #   foo = bar unless condition
       #
       class RedundantSelfAssignmentBranch < Base
-        include RangeHelp
         extend AutoCorrector
 
         MSG = 'Remove the self-assignment branch.'
@@ -34,16 +33,17 @@ module RuboCop
         PATTERN
 
         def on_lvasgn(node)
-          variable, expression = *node
+          expression = node.expression
+
           return unless use_if_and_else_branch?(expression)
 
           if_branch = expression.if_branch
           else_branch = expression.else_branch
           return if inconvertible_to_modifier?(if_branch, else_branch)
 
-          if self_assign?(variable, if_branch)
+          if self_assign?(node.name, if_branch)
             register_offense(expression, if_branch, else_branch, 'unless')
-          elsif self_assign?(variable, else_branch)
+          elsif self_assign?(node.name, else_branch)
             register_offense(expression, else_branch, if_branch, 'if')
           end
         end
@@ -62,7 +62,9 @@ module RuboCop
         end
 
         def multiple_statements?(branch)
-          branch && branch.children.compact.count > 1
+          return false unless branch&.begin_type?
+
+          !branch.children.empty?
         end
 
         def self_assign?(variable, branch)
@@ -73,6 +75,11 @@ module RuboCop
           add_offense(offense_branch) do |corrector|
             assignment_value = opposite_branch ? opposite_branch.source : 'nil'
             replacement = "#{assignment_value} #{keyword} #{if_node.condition.source}"
+            if opposite_branch.respond_to?(:heredoc?) && opposite_branch.heredoc?
+              replacement += opposite_branch.loc.heredoc_end.with(
+                begin_pos: opposite_branch.source_range.end_pos
+              ).source
+            end
 
             corrector.replace(if_node, replacement)
           end

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

@@ -16,7 +16,7 @@ module RuboCop
       #   This cop is unsafe, because `sort...last` and `max` may not return the
       #   same element in all cases.
       #
-      #   In an enumerable where there are multiple elements where `a <=> b == 0`,
+      #   In an enumerable where there are multiple elements where ``a <=> b == 0``,
       #   or where the transformation done by the `sort_by` block has the
       #   same result, `sort.last` and `max` (or `sort_by.last` and `max_by`)
       #   will return different elements. `sort.last` will return the last
@@ -87,15 +87,15 @@ module RuboCop
         # @!method redundant_sort?(node)
         def_node_matcher :redundant_sort?, <<~MATCHER
           {
-            (send $(send _ $:sort) ${:last :first})
-            (send $(send _ $:sort) ${:[] :at :slice} {(int 0) (int -1)})
+            (call $(call _ $:sort) ${:last :first})
+            (call $(call _ $:sort) ${:[] :at :slice} {(int 0) (int -1)})
 
-            (send $(send _ $:sort_by _) ${:last :first})
+            (call $(call _ $:sort_by _) ${:last :first})
             (send $(send _ $:sort_by _) ${:[] :at :slice} {(int 0) (int -1)})
 
-            (send ({block numblock} $(send _ ${:sort_by :sort}) ...) ${:last :first})
-            (send
-              ({block numblock} $(send _ ${:sort_by :sort}) ...)
+            (call (any_block $(call _ ${:sort_by :sort}) ...) ${:last :first})
+            (call
+              (any_block $(call _ ${:sort_by :sort}) ...)
               ${:[] :at :slice} {(int 0) (int -1)}
             )
           }
@@ -108,6 +108,7 @@ module RuboCop
 
           register_offense(ancestor, sort_node, sorter, accessor)
         end
+        alias on_csend on_send
 
         private
 
@@ -129,13 +130,13 @@ module RuboCop
         end
 
         def offense_range(sort_node, node)
-          range_between(sort_node.loc.selector.begin_pos, node.loc.expression.end_pos)
+          range_between(sort_node.loc.selector.begin_pos, node.source_range.end_pos)
         end
 
         def message(node, sorter, accessor)
           accessor_source = range_between(
             node.loc.selector.begin_pos,
-            node.loc.expression.end_pos
+            node.source_range.end_pos
           ).source
 
           format(MSG,
@@ -146,7 +147,7 @@ module RuboCop
 
         def autocorrect(corrector, node, sort_node, sorter, accessor)
           # Remove accessor, e.g. `first` or `[-1]`.
-          corrector.remove(range_between(accessor_start(node), node.loc.expression.end_pos))
+          corrector.remove(range_between(accessor_start(node), node.source_range.end_pos))
           # Replace "sort" or "sort_by" with the appropriate min/max method.
           corrector.replace(sort_node.loc.selector, suggestion(sorter, accessor, arg_value(node)))
           # Replace to avoid syntax errors when followed by a logical operator.
@@ -180,7 +181,7 @@ module RuboCop
         end
 
         def arg_node(node)
-          node.arguments.first
+          node.first_argument
         end
 
         def arg_value(node)
@@ -198,9 +199,9 @@ module RuboCop
         end
 
         def with_logical_operator?(node)
-          return unless (parent = node.parent)
+          return false unless (parent = node.parent)
 
-          parent.or_type? || parent.and_type?
+          parent.operator_keyword?
         end
       end
     end

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

@@ -21,6 +21,7 @@ module RuboCop
 
         MSG_BLOCK = 'Use `sort` instead of `sort_by { |%<var>s| %<var>s }`.'
         MSG_NUMBLOCK = 'Use `sort` instead of `sort_by { _1 }`.'
+        MSG_ITBLOCK = 'Use `sort` instead of `sort_by { it }`.'
 
         def on_block(node)
           redundant_sort_by_block(node) do |send, var_name|
@@ -36,7 +37,17 @@ module RuboCop
           redundant_sort_by_numblock(node) do |send|
             range = sort_by_range(send, node)
 
-            add_offense(range, message: format(MSG_NUMBLOCK)) do |corrector|
+            add_offense(range, message: MSG_NUMBLOCK) do |corrector|
+              corrector.replace(range, 'sort')
+            end
+          end
+        end
+
+        def on_itblock(node)
+          redundant_sort_by_itblock(node) do |send|
+            range = sort_by_range(send, node)
+
+            add_offense(range, message: MSG_ITBLOCK) do |corrector|
               corrector.replace(range, 'sort')
             end
           end
@@ -46,12 +57,17 @@ module RuboCop
 
         # @!method redundant_sort_by_block(node)
         def_node_matcher :redundant_sort_by_block, <<~PATTERN
-          (block $(send _ :sort_by) (args (arg $_x)) (lvar _x))
+          (block $(call _ :sort_by) (args (arg $_x)) (lvar _x))
         PATTERN
 
         # @!method redundant_sort_by_numblock(node)
         def_node_matcher :redundant_sort_by_numblock, <<~PATTERN
-          (numblock $(send _ :sort_by) 1 (lvar :_1))
+          (numblock $(call _ :sort_by) 1 (lvar :_1))
+        PATTERN
+
+        # @!method redundant_sort_by_itblock(node)
+        def_node_matcher :redundant_sort_by_itblock, <<~PATTERN
+          (itblock $(call _ :sort_by) _ (lvar :it))
         PATTERN
 
         def sort_by_range(send, node)

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

@@ -36,13 +36,12 @@ module RuboCop
       #   STR
       class RedundantStringEscape < Base
         include MatchRange
-        include RangeHelp
         extend AutoCorrector
 
         MSG = 'Redundant escape of %<char>s inside string literal.'
 
         def on_str(node)
-          return if node.parent&.regexp_type? || node.parent&.xstr_type? || node.character_literal?
+          return if node.parent&.type?(:regexp, :xstr) || node.character_literal?
 
           str_contents_range = str_contents_range(node)
 
@@ -64,10 +63,10 @@ module RuboCop
         def str_contents_range(node)
           if heredoc?(node)
             node.loc.heredoc_body
+          elsif node.str_type?
+            node.source_range
           elsif begin_loc_present?(node)
             contents_range(node)
-          else
-            node.loc.expression
           end
         end
 
@@ -134,12 +133,12 @@ module RuboCop
         end
 
         def percent_array_literal?(node)
-          (percent_w_literal?(node) || percent_w_upper_literal?(node))
+          percent_w_literal?(node) || percent_w_upper_literal?(node)
         end
 
         def heredoc_with_disabled_interpolation?(node)
           if heredoc?(node)
-            node.loc.expression.source.end_with?("'")
+            node.source.end_with?("'")
           elsif node.parent&.dstr_type?
             heredoc_with_disabled_interpolation?(node.parent)
           else
@@ -148,7 +147,7 @@ module RuboCop
         end
 
         def heredoc?(node)
-          (node.str_type? || node.dstr_type?) && node.heredoc?
+          node.type?(:str, :dstr) && node.heredoc?
         end
 
         def delimiter?(node, char)
@@ -158,6 +157,8 @@ module RuboCop
             return delimiter?(node.parent, char)
           end
 
+          return true unless node.loc.begin
+
           delimiters = [node.loc.begin.source[-1], node.loc.end.source[0]]
 
           delimiters.include?(char)

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

@@ -3,7 +3,16 @@
 module RuboCop
   module Cop
     module Style
-      # Enforces using // or %r around regular expressions.
+      # Enforces using `//` or `%r` around regular expressions.
+      #
+      # NOTE: The following `%r` cases using a regexp starts with a blank or `=`
+      # as a method argument allowed to prevent syntax errors.
+      #
+      # [source,ruby]
+      # ----
+      # do_something %r{ regexp} # `do_something / regexp/` is an invalid syntax.
+      # do_something %r{=regexp} # `do_something /=regexp/` is an invalid syntax.
+      # ----
       #
       # @example EnforcedStyle: slashes (default)
       #   # bad
@@ -146,12 +155,12 @@ module RuboCop
         end
 
         def preferred_delimiters
-          config.for_cop('Style/PercentLiteralDelimiters') ['PreferredDelimiters']['%r'].chars
+          config.for_cop('Style/PercentLiteralDelimiters')['PreferredDelimiters']['%r'].chars
         end
 
         def allowed_omit_parentheses_with_percent_r_literal?(node)
           return false unless node.parent&.call_type?
-          return true if node.content.start_with?(' ')
+          return true if node.content.start_with?(' ', '=')
 
           enforced_style = config.for_cop('Style/MethodCallWithArgsParentheses')['EnforcedStyle']
 

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

@@ -88,10 +88,7 @@ module RuboCop
           return unless previous_older_sibling
 
           add_offense(node, message: format(MSG, name: node.method_name)) do |corrector|
-            corrector.swap(
-              range_with_comments_and_lines(previous_older_sibling),
-              range_with_comments_and_lines(node.parent.if_type? ? node.parent : node)
-            )
+            autocorrect(corrector, node, previous_older_sibling)
           end
         end
 
@@ -106,14 +103,23 @@ module RuboCop
             next unless sibling.is_a?(AST::Node)
 
             sibling = sibling_node(sibling)
-            break unless sibling&.send_type? && sibling&.method?(node.method_name)
+            break unless sibling&.send_type? && sibling.method?(node.method_name)
             break unless sibling.arguments? && !sibling.receiver
             break unless in_same_section?(sibling, node)
+            break unless node.first_argument.str_type? && sibling.first_argument.str_type?
 
-            node.first_argument.source < sibling.first_argument.source
+            node.first_argument.value < sibling.first_argument.value
           end
         end
 
+        def autocorrect(corrector, node, previous_older_sibling)
+          range1 = range_with_comments_and_lines(previous_older_sibling)
+          range2 = range_with_comments_and_lines(node.parent.if_type? ? node.parent : node)
+
+          corrector.remove(range2)
+          corrector.insert_before(range1, range2.source)
+        end
+
         def search_node(node)
           node.parent.if_type? ? node.parent : node
         end
@@ -125,9 +131,7 @@ module RuboCop
         end
 
         def in_same_section?(node1, node2)
-          !node1.location.expression.with(
-            end_pos: node2.location.expression.end_pos
-          ).source.include?("\n\n")
+          !node1.source_range.join(node2.source_range.end).source.include?("\n\n")
         end
       end
     end

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

@@ -3,9 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for uses of rescue in its modifier form.
-      #
-      # The cop to check `rescue` in its modifier form is added for following
+      # Checks for uses of `rescue` in its modifier form is added for following
       # reasons:
       #
       # * The syntax of modifier form `rescue` can be misleading because it
@@ -69,21 +67,23 @@ module RuboCop
           node.parent && parentheses?(node.parent)
         end
 
+        # rubocop:disable Metrics/AbcSize
         def correct_rescue_block(corrector, node, parenthesized)
-          operation, rescue_modifier, = *node
-          *_, rescue_args = *rescue_modifier
+          operation = node.body
 
           node_indentation, node_offset = indentation_and_offset(node, parenthesized)
 
+          corrector.wrap(operation, '[', ']') if operation.array_type? && !operation.bracketed?
           corrector.remove(range_between(operation.source_range.end_pos, node.source_range.end_pos))
           corrector.insert_before(operation, "begin\n#{node_indentation}")
-          corrector.insert_after(operation, <<~RESCUE_CLAUSE.chop)
+          corrector.insert_after(heredoc_end(operation) || operation, <<~RESCUE_CLAUSE.chop)
 
             #{node_offset}rescue
-            #{node_indentation}#{rescue_args.source}
+            #{node_indentation}#{node.resbody_branches.first.body.source}
             #{node_offset}end
           RESCUE_CLAUSE
         end
+        # rubocop:enable Metrics/AbcSize
 
         def indentation_and_offset(node, parenthesized)
           node_indentation = indentation(node)
@@ -94,6 +94,18 @@ module RuboCop
           end
           [node_indentation, node_offset]
         end
+
+        def heredoc_end(node)
+          return unless node.call_type?
+
+          heredoc = node.arguments.reverse.find do |argument|
+            argument.respond_to?(:heredoc?) && argument.heredoc?
+          end
+
+          return unless heredoc
+
+          heredoc.loc.heredoc_end
+        end
       end
     end
   end

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

@@ -105,11 +105,11 @@ module RuboCop
         private
 
         def offense_for_implicit_enforced_style(node, error)
-          range = node.loc.keyword.join(error.loc.expression)
+          range = node.loc.keyword.join(error.source_range)
 
           add_offense(range, message: MSG_IMPLICIT) do |corrector|
             error = rescue_standard_error?(node)
-            range = range_between(node.loc.keyword.end_pos, error.loc.expression.end_pos)
+            range = range_between(node.loc.keyword.end_pos, error.source_range.end_pos)
 
             corrector.remove(range)
           end

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

@@ -3,9 +3,13 @@
 module RuboCop
   module Cop
     module Style
-      # Enforces consistency between 'return nil' and 'return'.
+      # Enforces consistency between `return nil` and `return`.
       #
-      # Supported styles are: return, return_nil.
+      # This cop is disabled by default. Because there seems to be a perceived semantic difference
+      # between `return` and `return nil`. The former can be seen as just halting evaluation,
+      # while the latter might be used when the return value is of specific concern.
+      #
+      # Supported styles are `return` and `return_nil`.
       #
       # @example EnforcedStyle: return (default)
       #   # bad
@@ -43,7 +47,7 @@ module RuboCop
 
         def on_return(node)
           # Check Lint/NonLocalExitFromIterator first before this cop
-          node.each_ancestor(:block, :def, :defs) do |n|
+          node.each_ancestor(:block, :any_def) do |n|
             break if scoped_node?(n)
 
             send_node, args_node, _body_node = *n
@@ -79,7 +83,7 @@ module RuboCop
         end
 
         def scoped_node?(node)
-          node.def_type? || node.defs_type? || node.lambda?
+          node.any_def_type? || node.lambda?
         end
 
         # @!method chained_send?(node)