rubocop 1.53.0 → 1.60.0

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

@@ -17,12 +17,11 @@ module RuboCop
         include Parentheses
         extend AutoCorrector
 
+        ALLOWED_NODE_TYPES = %i[and or send splat kwsplat].freeze
+
         # @!method square_brackets?(node)
         def_node_matcher :square_brackets?, '(send {(send _recv _msg) str array hash} :[] ...)'
 
-        # @!method range_end?(node)
-        def_node_matcher :range_end?, '^^{irange erange}'
-
         # @!method method_node_and_args(node)
         def_node_matcher :method_node_and_args, '$(call _recv _msg $...)'
 
@@ -54,7 +53,7 @@ module RuboCop
         def ignore_syntax?(node)
           return false unless (parent = node.parent)
 
-          parent.while_post_type? || parent.until_post_type? ||
+          parent.while_post_type? || parent.until_post_type? || parent.match_with_lvasgn_type? ||
             like_method_argument_parentheses?(parent)
         end
 
@@ -62,7 +61,8 @@ module RuboCop
           allowed_ancestor?(node) ||
             allowed_method_call?(node) ||
             allowed_multiple_expression?(node) ||
-            allowed_ternary?(node)
+            allowed_ternary?(node) ||
+            node.parent&.range_type?
         end
 
         def allowed_ancestor?(node)
@@ -98,7 +98,9 @@ module RuboCop
         end
 
         def like_method_argument_parentheses?(node)
-          node.send_type? && node.arguments.one? && !node.parenthesized? &&
+          return false if !node.send_type? && !node.super_type? && !node.yield_type?
+
+          node.arguments.one? && !node.parenthesized? &&
             !node.arithmetic_operation? && node.first_argument.begin_type?
         end
 
@@ -109,34 +111,69 @@ module RuboCop
 
         def first_arg_begins_with_hash_literal?(node)
           # Don't flag `method ({key: value})` or `method ({key: value}.method)`
-          method_chain_begins_with_hash_literal?(node.children.first) &&
-            first_argument?(node) &&
-            !parentheses?(node.parent)
+          hash_literal = method_chain_begins_with_hash_literal(node.children.first)
+          if (root_method = node.each_ancestor(:send).to_a.last)
+            parenthesized = root_method.parenthesized_call?
+          end
+          hash_literal && first_argument?(node) && !parentheses?(hash_literal) && !parenthesized
         end
 
-        def method_chain_begins_with_hash_literal?(node)
-          return false if node.nil?
-          return true if node.hash_type?
-          return false unless node.send_type?
+        def method_chain_begins_with_hash_literal(node)
+          return if node.nil?
+          return node if node.hash_type?
+          return unless node.send_type?
 
-          method_chain_begins_with_hash_literal?(node.children.first)
+          method_chain_begins_with_hash_literal(node.children.first)
         end
 
         def check(begin_node)
           node = begin_node.children.first
-          return offense(begin_node, 'a keyword') if keyword_with_redundant_parentheses?(node)
-          return offense(begin_node, 'a literal') if disallowed_literal?(begin_node, node)
-          return offense(begin_node, 'a variable') if node.variable?
-          return offense(begin_node, 'a constant') if node.const_type?
 
-          return offense(begin_node, 'an interpolated expression') if interpolation?(begin_node)
+          if (message = find_offense_message(begin_node, node))
+            return offense(begin_node, message)
+          end
 
           check_send(begin_node, node) if node.call_type?
         end
 
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        def find_offense_message(begin_node, node)
+          return 'a keyword' if keyword_with_redundant_parentheses?(node)
+          return 'a literal' if disallowed_literal?(begin_node, node)
+          return 'a variable' if node.variable?
+          return 'a constant' if node.const_type?
+          if node.lambda_or_proc? && (node.braces? || node.send_node.lambda_literal?)
+            return 'an expression'
+          end
+          return 'an interpolated expression' if interpolation?(begin_node)
+
+          return if begin_node.chained?
+
+          if node.and_type? || node.or_type?
+            return if node.semantic_operator? && begin_node.parent
+            return if node.multiline? && allow_in_multiline_conditions?
+            return if ALLOWED_NODE_TYPES.include?(begin_node.parent&.type)
+            return if begin_node.parent&.if_type? && begin_node.parent&.ternary?
+
+            'a logical expression'
+          elsif node.respond_to?(:comparison_method?) && node.comparison_method?
+            return unless begin_node.parent.nil?
+
+            'a comparison expression'
+          end
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+
         # @!method interpolation?(node)
         def_node_matcher :interpolation?, '[^begin ^^dstr]'
 
+        def allow_in_multiline_conditions?
+          parentheses_around_condition_config = config.for_cop('Style/ParenthesesAroundCondition')
+          return false unless parentheses_around_condition_config['Enabled']
+
+          !!parentheses_around_condition_config['AllowInMultilineConditions']
+        end
+
         def check_send(begin_node, node)
           return check_unary(begin_node, node) if node.unary_operation?
 
@@ -201,7 +238,6 @@ module RuboCop
         def method_call_with_redundant_parentheses?(node)
           return false unless node.call_type?
           return false if node.prefix_not?
-          return false if range_end?(node)
 
           send_node, args = method_node_and_args(node)
 
@@ -213,7 +249,13 @@ module RuboCop
         end
 
         def first_argument?(node)
-          first_send_argument?(node) || first_super_argument?(node) || first_yield_argument?(node)
+          if first_send_argument?(node) ||
+             first_super_argument?(node) ||
+             first_yield_argument?(node)
+            return true
+          end
+
+          node.each_ancestor.any? { |ancestor| first_argument?(ancestor) }
         end
 
         # @!method first_send_argument?(node)

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

@@ -40,7 +40,9 @@ module RuboCop
           byteindex byterindex gsub gsub! partition rpartition scan split start_with? sub sub!
         ].freeze
         DETERMINISTIC_REGEX = /\A(?:#{LITERAL_REGEX})+\Z/.freeze
-        STR_SPECIAL_CHARS = %w[\n \" \' \\\\ \t \b \f \r].freeze
+        STR_SPECIAL_CHARS = %w[
+          \a \c \C \e \f \M \n \" \' \\\\ \t \b \f \r \u \v \x \0 \1 \2 \3 \4 \5 \6 \7
+        ].freeze
 
         def on_send(node)
           return unless (regexp_node = node.first_argument)
@@ -48,15 +50,14 @@ module RuboCop
           return if !regexp_node.regopt.children.empty? || regexp_node.content == ' '
           return unless determinist_regexp?(regexp_node)
 
-          new_argument = replacement(regexp_node)
-          quote = new_argument.include?('"') ? "'" : '"'
-          prefer = "#{quote}#{new_argument}#{quote}"
+          prefer = preferred_argument(regexp_node)
           message = format(MSG, prefer: prefer, current: regexp_node.source)
 
           add_offense(regexp_node, message: message) do |corrector|
             corrector.replace(regexp_node, prefer)
           end
         end
+        alias on_csend on_send
 
         private
 
@@ -64,6 +65,19 @@ module RuboCop
           DETERMINISTIC_REGEX.match?(regexp_node.source)
         end
 
+        def preferred_argument(regexp_node)
+          new_argument = replacement(regexp_node)
+
+          if new_argument.include?('"')
+            new_argument.gsub!("'", "\\\\'")
+            quote = "'"
+          else
+            quote = '"'
+          end
+
+          "#{quote}#{new_argument}#{quote}"
+        end
+
         def replacement(regexp_node)
           regexp_content = regexp_node.content
           stack = []

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

@@ -22,13 +22,18 @@ module RuboCop
       #     return something
       #   end
       #
-      #   # good
+      #   # bad
       #   def test
       #     return something if something_else
       #   end
       #
       #   # good
       #   def test
+      #     something if something_else
+      #   end
+      #
+      #   # good
+      #   def test
       #     if x
       #     elsif y
       #     else
@@ -53,7 +58,7 @@ module RuboCop
 
         MSG = 'Redundant `return` detected.'
         MULTI_RETURN_MSG = 'To return multiple values, use an array.'
-        RESTRICT_ON_SEND = %i[define_method define_singleton_method].freeze
+        RESTRICT_ON_SEND = %i[define_method define_singleton_method lambda].freeze
 
         def on_send(node)
           return unless (parent = node.parent) && parent.block_type?
@@ -136,7 +141,7 @@ module RuboCop
         end
 
         def check_if_node(node)
-          return if node.modifier_form? || node.ternary?
+          return if node.ternary?
 
           check_branch(node.if_branch)
           check_branch(node.else_branch)

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
       #
@@ -107,8 +108,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)
@@ -155,6 +156,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) ||

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

@@ -75,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 ({block numblock} $(call _ ${:sort_by :sort}) ...) ${:last :first})
+            (call
+              ({block numblock} $(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
 
@@ -180,7 +181,7 @@ module RuboCop
         end
 
         def arg_node(node)
-          node.arguments.first
+          node.first_argument
         end
 
         def arg_value(node)

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

@@ -46,12 +46,12 @@ 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
 
         def sort_by_range(send, node)

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

@@ -133,7 +133,7 @@ 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)

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

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

@@ -31,7 +31,7 @@ module RuboCop
       #     do_something?
       #   end
       #
-      # @example AllowedMethod: ['foo?']
+      # @example AllowedMethods: ['foo?']
       #   # good
       #   def foo?
       #     return if condition
@@ -39,7 +39,7 @@ module RuboCop
       #     do_something?
       #   end
       #
-      # @example AllowedPattern: [/foo/]
+      # @example AllowedPatterns: [/foo/]
       #   # good
       #   def foo?
       #     return if condition
@@ -52,7 +52,7 @@ module RuboCop
         include AllowedMethods
         include AllowedPattern
 
-        MSG = 'Use `return false` instead of `%<prefer>s` in the predicate method.'
+        MSG = 'Return `false` instead of `nil` in predicate methods.'
 
         # @!method return_nil?(node)
         def_node_matcher :return_nil?, <<~PATTERN
@@ -65,16 +65,30 @@ module RuboCop
           return unless (body = node.body)
 
           body.each_descendant(:return) do |return_node|
-            next unless return_nil?(return_node)
+            register_offense(return_node, 'return false') if return_nil?(return_node)
+          end
 
-            message = format(MSG, prefer: return_node.source)
+          return unless (nil_node = nil_node_at_the_end_of_method_body(body))
 
-            add_offense(return_node, message: message) do |corrector|
-              corrector.replace(return_node, 'return false')
-            end
-          end
+          register_offense(nil_node, 'false')
         end
         alias on_defs on_def
+
+        private
+
+        def nil_node_at_the_end_of_method_body(body)
+          return body if body.nil_type?
+          return unless body.begin_type?
+          return unless (last_child = body.children.last)
+
+          last_child if last_child.is_a?(AST::Node) && last_child.nil_type?
+        end
+
+        def register_offense(offense_node, replacement)
+          add_offense(offense_node) do |corrector|
+            corrector.replace(offense_node, replacement)
+          end
+        end
       end
     end
   end

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

@@ -35,7 +35,7 @@ module RuboCop
 
         # @!method sample_candidate?(node)
         def_node_matcher :sample_candidate?, <<~PATTERN
-          (send $(send _ :shuffle $...) ${:#{RESTRICT_ON_SEND.join(' :')}} $...)
+          (call $(call _ :shuffle $...) ${:#{RESTRICT_ON_SEND.join(' :')}} $...)
         PATTERN
 
         def on_send(node)
@@ -52,6 +52,7 @@ module RuboCop
             end
           end
         end
+        alias on_csend on_send
 
         private
 

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

@@ -55,8 +55,8 @@ module RuboCop
         # @!method regexp_match?(node)
         def_node_matcher :regexp_match?, <<~PATTERN
           {
-            (block send (args (arg $_)) ${(send _ %REGEXP_METHODS _) match-with-lvasgn})
-            (numblock send $1 ${(send _ %REGEXP_METHODS _) match-with-lvasgn})
+            (block call (args (arg $_)) ${(send _ %REGEXP_METHODS _) match-with-lvasgn})
+            (numblock call $1 ${(send _ %REGEXP_METHODS _) match-with-lvasgn})
           }
         PATTERN
 
@@ -64,9 +64,9 @@ module RuboCop
         # @!method creates_hash?(node)
         def_node_matcher :creates_hash?, <<~PATTERN
           {
-            (send (const _ :Hash) {:new :[]} ...)
-            (block (send (const _ :Hash) :new ...) ...)
-            (send _ { :to_h :to_hash } ...)
+            (call (const _ :Hash) {:new :[]} ...)
+            (block (call (const _ :Hash) :new ...) ...)
+            (call _ { :to_h :to_hash } ...)
           }
         PATTERN
 
@@ -100,6 +100,7 @@ module RuboCop
           register_offense(node, block_node, regexp, replacement)
         end
         # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        alias on_csend on_send
 
         private
 
@@ -146,7 +147,7 @@ module RuboCop
           return node.child_nodes.first if node.match_with_lvasgn_type?
 
           if node.receiver.lvar_type? &&
-             (block.numblock_type? || node.receiver.source == block.arguments.first.source)
+             (block.numblock_type? || node.receiver.source == block.first_argument.source)
             node.first_argument
           elsif node.first_argument.lvar_type?
             node.receiver

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

@@ -16,7 +16,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use self-assignment shorthand `%<method>s=`.'
-        OPS = %i[+ - * ** / | &].freeze
+        OPS = %i[+ - * ** / % ^ << >> | &].freeze
 
         def self.autocorrect_incompatible_with
           [Layout::SpaceAroundOperators]

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

@@ -62,9 +62,6 @@ module RuboCop
         private
 
         def check_for_line_terminator_or_opener
-          # Make the obvious check first
-          return unless processed_source.raw_source.include?(';')
-
           each_semicolon do |line, column, token_before_semicolon|
             register_semicolon(line, column, false, token_before_semicolon)
           end
@@ -83,6 +80,7 @@ module RuboCop
           processed_source.tokens.group_by(&:line)
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def semicolon_position(tokens)
           if tokens.last.semicolon?
             -1
@@ -93,10 +91,13 @@ module RuboCop
           elsif exist_semicolon_after_left_curly_brace?(tokens) ||
                 exist_semicolon_after_left_string_interpolation_brace?(tokens)
             2
+          elsif exist_semicolon_after_left_lambda_curly_brace?(tokens)
+            3
           elsif exist_semicolon_before_right_string_interpolation_brace?(tokens)
             -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?
@@ -106,6 +107,10 @@ module RuboCop
           tokens[1]&.left_curly_brace? && tokens[2]&.semicolon?
         end
 
+        def exist_semicolon_after_left_lambda_curly_brace?(tokens)
+          tokens[2]&.type == :tLAMBEG && tokens[3]&.semicolon?
+        end
+
         def exist_semicolon_before_right_string_interpolation_brace?(tokens)
           tokens[-3]&.type == :tSTRING_DEND && tokens[-4]&.semicolon?
         end

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

@@ -3,8 +3,11 @@
 module RuboCop
   module Cop
     module Style
-      # Sometimes using dig method ends up with just a single
-      # argument. In such cases, dig should be replaced with [].
+      # Sometimes using `dig` method ends up with just a single
+      # argument. In such cases, dig should be replaced with `[]`.
+      #
+      # Since replacing `hash&.dig(:key)` with `hash[:key]` could potentially lead to error,
+      # calls to the `dig` method using safe navigation will be ignored.
       #
       # @safety
       #   This cop is unsafe because it cannot be guaranteed that the receiver
@@ -33,6 +36,7 @@ module RuboCop
 
         MSG = 'Use `%<receiver>s[%<argument>s]` instead of `%<original>s`.'
         RESTRICT_ON_SEND = %i[dig].freeze
+        IGNORED_ARGUMENT_TYPES = %i[block_pass forwarded_restarg forwarded_args hash].freeze
 
         # @!method single_argument_dig?(node)
         def_node_matcher :single_argument_dig?, <<~PATTERN
@@ -44,7 +48,7 @@ module RuboCop
 
           expression = single_argument_dig?(node)
           return unless expression
-          return if expression.forwarded_args_type?
+          return if IGNORED_ARGUMENT_TYPES.include?(expression.type)
 
           receiver = node.receiver.source
           argument = expression.source

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for single-line `do`...`end` block.
+      #
+      # In practice a single line `do`...`end` is autocorrected when `EnforcedStyle: semantic`
+      # in `Style/BlockDelimiters`. The autocorrection maintains the `do` ... `end` syntax to
+      # preserve semantics and does not change it to `{`...`}` block.
+      #
+      # @example
+      #
+      #   # bad
+      #   foo do |arg| bar(arg) end
+      #
+      #   # good
+      #   foo do |arg|
+      #     bar(arg)
+      #   end
+      #
+      #   # bad
+      #   ->(arg) do bar(arg) end
+      #
+      #   # good
+      #   ->(arg) { bar(arg) }
+      #
+      class SingleLineDoEndBlock < Base
+        extend AutoCorrector
+
+        MSG = 'Prefer multiline `do`...`end` block.'
+
+        # rubocop:disable Metrics/AbcSize
+        def on_block(node)
+          return if !node.single_line? || node.braces?
+
+          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?
+              corrector.remove(node.loc.end)
+              corrector.insert_after(node_body.loc.heredoc_end, "\nend")
+            else
+              corrector.insert_before(node.loc.end, "\n")
+            end
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+        alias on_numblock on_block
+
+        private
+
+        def do_line(node)
+          if node.numblock_type? || node.arguments.children.empty? || node.send_node.lambda_literal?
+            node.loc.begin
+          else
+            node.arguments
+          end
+        end
+
+        def x(corrector, node); end
+      end
+    end
+  end
+end