rubocop 1.69.0 → 1.79.2

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

@@ -86,6 +86,10 @@ module RuboCop
       #   foo.baz = bar if foo
       #   foo.baz + bar if foo
       #   foo.bar > 2 if foo
+      #
+      #   foo ? foo[index] : nil    # Ignored `foo&.[](index)` due to unclear readability benefit.
+      #   foo ? foo[idx] = v : nil  # Ignored `foo&.[]=(idx, v)` due to unclear readability benefit.
+      #   foo ? foo * 42 : nil      # Ignored `foo&.*(42)` due to unclear readability benefit.
       class SafeNavigation < Base # rubocop:disable Metrics/ClassLength
         include NilMethods
         include RangeHelp
@@ -146,6 +150,7 @@ module RuboCop
 
           body = extract_if_body(node)
           method_call = receiver.parent
+          return if dotless_operator_call?(method_call) || method_call.double_colon?
 
           removal_ranges = [begin_range(node, body), end_range(node, body)]
 
@@ -174,12 +179,19 @@ module RuboCop
               range_with_surrounding_space(range: lhs.source_range, side: :right),
               range_with_surrounding_space(range: lhs_operator_range, side: :right),
               offense_range: range_between(lhs.source_range.begin_pos, rhs.source_range.end_pos)
-            )
+            ) do |corrector|
+              corrector.replace(rhs_receiver, lhs_receiver.source)
+            end
+            ignore_node(node)
           end
         end
 
+        private
+
         def report_offense(node, rhs, rhs_receiver, *removal_ranges, offense_range: node)
           add_offense(offense_range) do |corrector|
+            next if ignored_node?(node)
+
             # If the RHS is an `or` we cannot safely autocorrect because in order to remove
             # the non-nil check we need to add safe-navs to all clauses where the receiver is used
             next if and_with_rhs_or?(node)
@@ -193,8 +205,6 @@ module RuboCop
           end
         end
 
-        private
-
         def find_method_chain(node)
           return node unless node&.parent&.call_type?
 
@@ -227,10 +237,10 @@ module RuboCop
         end
 
         def offending_node?(node, lhs_receiver, rhs, rhs_receiver) # rubocop:disable Metrics/CyclomaticComplexity
-          return false if lhs_receiver != rhs_receiver || rhs_receiver.nil?
+          return false if !matching_nodes?(lhs_receiver, rhs_receiver) || rhs_receiver.nil?
           return false if use_var_only_in_unless_modifier?(node, lhs_receiver)
           return false if chain_length(rhs, rhs_receiver) > max_chain_length
-          return false if unsafe_method_used?(rhs, rhs_receiver.parent)
+          return false if unsafe_method_used?(node, rhs, rhs_receiver.parent)
           return false if rhs.send_type? && rhs.method?(:empty?)
 
           true
@@ -248,6 +258,14 @@ module RuboCop
           end
         end
 
+        def dotless_operator_call?(method_call)
+          method_call = method_call.parent while method_call.parent.send_type?
+
+          return false if method_call.loc.dot
+
+          method_call.method?(:[]) || method_call.method?(:[]=) || method_call.operator_method?
+        end
+
         def handle_comments(corrector, node, method_call)
           comments = comments(node)
           return if comments.empty?
@@ -306,34 +324,47 @@ module RuboCop
 
           receiver = method_chain.receiver
 
-          return receiver if receiver == checked_variable
+          return receiver if matching_nodes?(receiver, checked_variable)
 
           find_matching_receiver_invocation(receiver, checked_variable)
         end
 
+        def matching_nodes?(left, right)
+          left == right || matching_call_nodes?(left, right)
+        end
+
+        def matching_call_nodes?(left, right)
+          return false unless left && right.respond_to?(:call_type?)
+
+          left.call_type? && right.call_type? && left.children == right.children
+        end
+
         def chain_length(method_chain, method)
-          method.each_ancestor(:send, :csend).inject(0) do |total, ancestor|
+          method.each_ancestor(:call).inject(0) do |total, ancestor|
             break total + 1 if ancestor == method_chain
 
             total + 1
           end
         end
 
-        def unsafe_method_used?(method_chain, method)
-          return true if unsafe_method?(method)
+        def unsafe_method_used?(node, method_chain, method)
+          return true if unsafe_method?(node, method)
 
           method.each_ancestor(:send).any? do |ancestor|
-            break true unless config.for_cop('Lint/SafeNavigationChain')['Enabled']
+            break true unless config.cop_enabled?('Lint/SafeNavigationChain')
 
-            break true if unsafe_method?(ancestor)
+            break true if unsafe_method?(node, ancestor)
             break true if nil_methods.include?(ancestor.method_name)
             break false if ancestor == method_chain
           end
         end
 
-        def unsafe_method?(send_node)
-          negated?(send_node) ||
-            send_node.assignment? ||
+        def unsafe_method?(node, send_node)
+          return true if negated?(send_node)
+
+          return false if node.respond_to?(:ternary?) && node.ternary?
+
+          send_node.assignment? ||
             (!send_node.dot? && !send_node.safe_navigation?)
         end
 
@@ -362,8 +393,7 @@ module RuboCop
                                                  method_chain)
           start_method.each_ancestor do |ancestor|
             break unless %i[send block].include?(ancestor.type)
-            next unless ancestor.send_type?
-            next if ancestor.safe_navigation?
+            next if !ancestor.send_type? || ancestor.operator_method?
 
             corrector.insert_before(ancestor.loc.dot, '&')
 

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

@@ -59,6 +59,7 @@ module RuboCop
           {
             (block call (args (arg $_)) ${(send _ %REGEXP_METHODS _) match-with-lvasgn})
             (numblock call $1 ${(send _ %REGEXP_METHODS _) match-with-lvasgn})
+            (itblock call $_ ${(send _ %REGEXP_METHODS _) match-with-lvasgn})
           }
         PATTERN
 
@@ -137,6 +138,7 @@ 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?
+
           return unless calls_lvar?(regexp_method_send_node, block_arg_name)
 
           regexp_method_send_node
@@ -150,7 +152,8 @@ 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.first_argument.source)
+             (block.type?(:numblock, :itblock) ||
+              node.receiver.source == block.first_argument.source)
             node.first_argument
           elsif node.first_argument.lvar_type?
             node.receiver

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

@@ -164,7 +164,7 @@ module RuboCop
 
           ast = processed_source.ast
           @range_nodes = ast.range_type? ? [ast] : []
-          @range_nodes.concat(ast.each_descendant(:irange, :erange).to_a)
+          @range_nodes.concat(ast.each_descendant(:range).to_a)
         end
       end
     end

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

@@ -68,7 +68,7 @@ module RuboCop
         def on_send(node)
           return if allow_send? && !node.method?(:public_send)
           return unless (first_argument = node.first_argument)
-          return unless STATIC_METHOD_NAME_NODE_TYPES.include?(first_argument.type)
+          return unless first_argument.type?(*STATIC_METHOD_NAME_NODE_TYPES)
 
           offense_range = offense_range(node)
           method_name = first_argument.value
@@ -83,6 +83,7 @@ module RuboCop
             end
           end
         end
+        alias on_csend on_send
         # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         private

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

@@ -10,7 +10,7 @@ module RuboCop
       # parameters.
       #
       # Configuration option: Methods
-      # Should be set to use this cop. Array of hashes, where each key is the
+      # Should be set to use this cop. `Array` of hashes, where each key is the
       # method name and value - array of argument names.
       #
       # @example Methods: [{reduce: %w[a b]}]

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

@@ -56,11 +56,13 @@ module RuboCop
         end
         # rubocop:enable Metrics/AbcSize
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
         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
@@ -68,8 +70,7 @@ module RuboCop
         end
 
         def single_line_blocks_preferred?
-          redundant_line_break_config = @config.for_cop('Layout/RedundantLineBreak')
-          redundant_line_break_config['Enabled'] && redundant_line_break_config['InspectBlocks']
+          @config.for_enabled_cop('Layout/RedundantLineBreak')['InspectBlocks']
         end
       end
     end

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

@@ -8,9 +8,9 @@ module RuboCop
       #
       # 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
@@ -65,10 +65,10 @@ 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? ||
+          return false if body_node.basic_conditional? || body_node.parent.assignment_method? ||
                           NOT_SUPPORTED_ENDLESS_METHOD_BODY_TYPES.include?(body_node.type)
 
-          !(body_node.begin_type? || body_node.kwbegin_type?)
+          !body_node.type?(:begin, :kwbegin)
         end
 
         def correct_to_multiline(corrector, node)
@@ -86,10 +86,10 @@ module RuboCop
         end
 
         def correct_to_endless(corrector, node)
-          self_receiver = node.self_receiver? ? 'self.' : ''
+          receiver = "#{node.receiver.source}." if node.receiver
           arguments = node.arguments.any? ? node.arguments.source : '()'
           body_source = method_body_source(node.body)
-          replacement = "def #{self_receiver}#{node.method_name}#{arguments} = #{body_source}"
+          replacement = "def #{receiver}#{node.method_name}#{arguments} = #{body_source}"
 
           corrector.replace(node, replacement)
         end
@@ -130,14 +130,16 @@ 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 disallow_endless_method_style?
-          endless_method_config = config.for_cop('Style/EndlessMethod')
-          return true unless endless_method_config['Enabled']
+          return true unless config.cop_enabled?('Style/EndlessMethod')
 
-          endless_method_config['EnforcedStyle'] == 'disallow'
+          config.for_cop('Style/EndlessMethod')['EnforcedStyle'] == 'disallow'
         end
       end
     end

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

@@ -78,38 +78,67 @@ module RuboCop
           return unless node.arguments.one?
 
           range_node = node.first_argument
-          selector = node.loc.selector
-          unless (message, removal_range = offense_message_with_removal_range(range_node, selector))
-            return
-          end
+          offense_range = find_offense_range(node)
+          return unless (message, removal_range =
+                           offense_message_with_removal_range(node, range_node, offense_range))
+
+          # Changing the range to beginningless or endless when unparenthesized
+          # changes the semantics of the code, and thus will not be considered
+          # an offense.
+          return if removal_range != offense_range && unparenthesized_call?(node)
 
-          add_offense(selector, message: message) do |corrector|
+          add_offense(offense_range, message: message) do |corrector|
             corrector.remove(removal_range)
           end
         end
+        alias on_csend on_send
 
         private
 
-        def offense_message_with_removal_range(range_node, selector)
+        def unparenthesized_call?(node)
+          node.loc.dot && !node.parenthesized?
+        end
+
+        def find_offense_range(node)
+          if node.loc.dot
+            node.loc.dot.join(node.source_range.end)
+          else
+            node.loc.selector
+          end
+        end
+
+        def offense_message_with_removal_range(node, range_node, offense_range)
           if range_from_zero_till_minus_one?(range_node)
-            [format(MSG_USELESS_RANGE, prefer: selector.source), selector]
+            [format(MSG_USELESS_RANGE, prefer: offense_range.source), offense_range]
           elsif range_till_minus_one?(range_node)
             [
-              format(MSG, prefer: endless(range_node), current: selector.source), range_node.end
+              offense_message_for_partial_range(node, endless(range_node), offense_range),
+              range_node.end
             ]
           elsif range_from_zero?(range_node) && target_ruby_version >= 2.7
             [
-              format(MSG, prefer: beginless(range_node), current: selector.source), range_node.begin
+              offense_message_for_partial_range(node, beginless(range_node), offense_range),
+              range_node.begin
             ]
           end
         end
 
+        def offense_message_for_partial_range(node, prefer, offense_range)
+          current = node.loc.dot ? arguments_source(node) : offense_range.source
+          prefer = "[#{prefer}]" unless node.loc.dot
+          format(MSG, prefer: prefer, current: current)
+        end
+
         def endless(range_node)
-          "[#{range_node.begin.source}#{range_node.loc.operator.source}]"
+          "#{range_node.begin.source}#{range_node.loc.operator.source}"
         end
 
         def beginless(range_node)
-          "[#{range_node.loc.operator.source}#{range_node.end.source}]"
+          "#{range_node.loc.operator.source}#{range_node.end.source}"
+        end
+
+        def arguments_source(node)
+          node.first_argument.source_range.join(node.last_argument.source_range.end).source
         end
       end
     end

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

@@ -96,11 +96,7 @@ module RuboCop
         end
 
         def autocorrect(corrector, node, if_branch)
-          if node.condition.or_type? || node.condition.assignment?
-            corrector.wrap(node.condition, '(', ')')
-          end
-
-          if outer_condition_modify_form?(node, if_branch)
+          if node.modifier_form?
             autocorrect_outer_condition_modify_form(corrector, node, if_branch)
           else
             autocorrect_outer_condition_basic(corrector, node, if_branch)
@@ -108,74 +104,49 @@ module RuboCop
         end
 
         def autocorrect_outer_condition_basic(corrector, node, if_branch)
-          correct_from_unless_to_if(corrector, node) if node.unless?
-
-          outer_condition = node.condition
-          correct_outer_condition(corrector, outer_condition)
+          correct_node(corrector, node)
 
-          and_operator = if_branch.unless? ? ' && !' : ' && '
           if if_branch.modifier_form?
-            correct_for_guard_condition_style(corrector, outer_condition, if_branch, and_operator)
+            correct_for_guard_condition_style(corrector, node, if_branch)
           else
-            correct_for_basic_condition_style(corrector, node, if_branch, and_operator)
+            correct_for_basic_condition_style(corrector, node, if_branch)
             correct_for_comment(corrector, node, if_branch)
           end
         end
 
-        def autocorrect_outer_condition_modify_form(corrector, node, if_branch)
-          correct_from_unless_to_if(corrector, if_branch, is_modify_form: true) if if_branch.unless?
-          correct_for_outer_condition_modify_form_style(corrector, node, if_branch)
-        end
-
-        def correct_from_unless_to_if(corrector, node, is_modify_form: false)
-          corrector.replace(node.loc.keyword, 'if')
-
-          insert_bang(corrector, node, is_modify_form)
+        def correct_node(corrector, node)
+          corrector.replace(node.loc.keyword, 'if') if node.unless? && !part_of_ignored_node?(node)
+          corrector.replace(node.condition, chainable_condition(node))
+          ignore_node(node)
         end
 
-        def correct_for_guard_condition_style(corrector, outer_condition, if_branch, and_operator)
-          condition = if_branch.condition
-          corrector.insert_after(outer_condition, "#{and_operator}#{replace_condition(condition)}")
+        def correct_for_guard_condition_style(corrector, node, if_branch)
+          corrector.insert_after(node.condition, " && #{chainable_condition(if_branch)}")
 
-          range = range_between(if_branch.loc.keyword.begin_pos, condition.source_range.end_pos)
+          range = range_between(
+            if_branch.loc.keyword.begin_pos, if_branch.condition.source_range.end_pos
+          )
           corrector.remove(range_with_surrounding_space(range, newlines: false))
-          corrector.remove(if_branch.loc.keyword)
         end
 
-        def correct_for_basic_condition_style(corrector, node, if_branch, and_operator)
+        def correct_for_basic_condition_style(corrector, node, if_branch)
           range = range_between(
             node.condition.source_range.end_pos, if_branch.condition.source_range.begin_pos
           )
-          corrector.replace(range, and_operator)
-          corrector.remove(range_by_whole_lines(node.loc.end, include_final_newline: true))
-
-          wrap_condition(corrector, if_branch.condition)
-        end
+          corrector.replace(range, ' && ')
 
-        def wrap_condition(corrector, condition)
-          # Handle `send` and `block` nodes that need to be wrapped in parens
-          # FIXME: autocorrection prevents syntax errors by wrapping the entire node in parens,
-          #        but wrapping the argument list would be a more ergonomic correction.
-          node_to_check = condition&.block_type? ? condition.send_node : condition
-          return unless wrap_condition?(node_to_check)
+          corrector.replace(if_branch.condition, chainable_condition(if_branch))
 
-          if condition.call_type?
-            source = parenthesized_method_arguments(condition)
-
-            corrector.replace(condition, source)
-          else
-            corrector.wrap(condition, '(', ')')
-          end
+          corrector.remove(range_by_whole_lines(node.loc.end, include_final_newline: true))
         end
 
-        def correct_for_outer_condition_modify_form_style(corrector, node, if_branch)
-          condition = if_branch.condition
-          corrector.insert_before(condition,
-                                  "#{'!' if node.unless?}#{replace_condition(node.condition)} && ")
+        def autocorrect_outer_condition_modify_form(corrector, node, if_branch)
+          correct_node(corrector, if_branch)
+
+          corrector.insert_before(if_branch.condition, "#{chainable_condition(node)} && ")
 
-          corrector.remove(node.condition)
-          corrector.remove(range_with_surrounding_space(node.loc.keyword, newlines: false))
-          corrector.replace(if_branch.loc.keyword, 'if')
+          range = range_between(node.loc.keyword.begin_pos, node.condition.source_range.end_pos)
+          corrector.remove(range_with_surrounding_space(range, newlines: false))
         end
 
         def correct_for_comment(corrector, node, if_branch)
@@ -187,67 +158,47 @@ module RuboCop
           corrector.insert_before(node.loc.keyword, comment_text) unless comments.empty?
         end
 
-        def correct_outer_condition(corrector, condition)
-          return unless require_parentheses?(condition)
+        def chainable_condition(node)
+          wrapped_condition = add_parentheses_if_needed(node.condition)
 
-          end_pos = condition.loc.selector.end_pos
-          begin_pos = condition.first_argument.source_range.begin_pos
-          return if end_pos > begin_pos
+          return wrapped_condition if node.if?
 
-          range = range_between(end_pos, begin_pos)
-          corrector.remove(range)
-          corrector.insert_after(range, '(')
-          corrector.insert_after(condition.last_argument, ')')
+          node.condition.and_type? ? "!(#{wrapped_condition})" : "!#{wrapped_condition}"
         end
 
-        def insert_bang(corrector, node, is_modify_form)
-          condition = node.condition
+        def add_parentheses_if_needed(condition)
+          # Handle `send` and `block` nodes that need to be wrapped in parens
+          # FIXME: autocorrection prevents syntax errors by wrapping the entire node in parens,
+          #        but wrapping the argument list would be a more ergonomic correction.
+          node_to_check = condition&.any_block_type? ? condition.send_node : condition
+          return condition.source unless add_parentheses?(node_to_check)
 
-          if (condition.send_type? && condition.comparison_method? && !condition.parenthesized?) ||
-             (is_modify_form && wrap_condition?(condition))
-            corrector.wrap(node.condition, '!(', ')')
+          if parenthesize_method?(condition)
+            parenthesized_method_arguments(condition)
           elsif condition.and_type?
-            insert_bang_for_and(corrector, node)
-          else
-            corrector.insert_before(condition, '!')
-          end
-        end
-
-        def insert_bang_for_and(corrector, node)
-          lhs, rhs = *node # rubocop:disable InternalAffairs/NodeDestructuring
-
-          if lhs.and_type?
-            insert_bang_for_and(corrector, lhs)
-            corrector.insert_before(rhs, '!') if rhs
+            parenthesized_and(condition)
           else
-            corrector.insert_before(lhs, '!')
-            corrector.insert_before(rhs, '!')
+            "(#{condition.source})"
           end
         end
 
-        def require_parentheses?(condition)
-          condition.call_type? && !condition.arguments.empty? && !condition.parenthesized? &&
-            !condition.comparison_method?
+        def parenthesize_method?(node)
+          node.call_type? && node.arguments.any? && !node.parenthesized? &&
+            !node.comparison_method? && !node.operator_method?
         end
 
-        def arguments_range(node)
-          range_between(
-            node.first_argument.source_range.begin_pos, node.last_argument.source_range.end_pos
-          )
-        end
+        def add_parentheses?(node)
+          return true if node.assignment? || node.or_type?
+          return true if assignment_in_and?(node)
+          return false unless node.call_type?
 
-        def wrap_condition?(node)
-          node.operator_keyword? || (node.call_type? && node.arguments.any? && !node.parenthesized?)
+          (node.arguments.any? && !node.parenthesized?) || node.prefix_not?
         end
 
-        def replace_condition(condition)
-          return condition.source unless wrap_condition?(condition)
+        def assignment_in_and?(node)
+          return false unless node.and_type?
 
-          if condition.call_type?
-            parenthesized_method_arguments(condition)
-          else
-            "(#{condition.source})"
-          end
+          node.each_descendant.any?(&:assignment?)
         end
 
         def parenthesized_method_arguments(node)
@@ -257,12 +208,28 @@ module RuboCop
           "#{method_call}(#{arguments})"
         end
 
-        def allow_modifier?
-          cop_config['AllowModifier']
+        def parenthesized_and(node)
+          # We only need to add parentheses around the last clause if it's an assignment,
+          # because other clauses will be unchanged by merging conditionals.
+          lhs = node.lhs.source
+          rhs = parenthesized_and_clause(node.rhs)
+          operator = range_with_surrounding_space(node.loc.operator, whitespace: true).source
+
+          "#{lhs}#{operator}#{rhs}"
         end
 
-        def outer_condition_modify_form?(node, if_branch)
-          node.condition.source_range.begin_pos > if_branch.condition.source_range.begin_pos
+        def parenthesized_and_clause(node)
+          if node.and_type?
+            parenthesized_and(node)
+          elsif node.assignment?
+            "(#{node.source})"
+          else
+            node.source
+          end
+        end
+
+        def allow_modifier?
+          cop_config['AllowModifier']
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # Check for parentheses around stabby lambda arguments.
+      # Checks for parentheses around stabby lambda arguments.
       # There are two different styles. Defaults to `require_parentheses`.
       #
       # @example EnforcedStyle: require_parentheses (default)