rubocop 1.71.1 → 1.92.0

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

@@ -50,10 +50,17 @@ module RuboCop
           unless when_node.conditions.first.first_line == when_node.conditions.last.last_line
             return true
           end
+          return true if ends_with_endless_range?(when_node.conditions.last)
           return false unless when_node.body
 
           same_line?(when_node, when_node.body)
         end
+
+        def ends_with_endless_range?(node)
+          node.each_node(:range).any? do |range|
+            range.end.nil? && range.source_range.end_pos == node.source_range.end_pos
+          end
+        end
       end
     end
   end

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

@@ -70,48 +70,59 @@ module RuboCop
           (send $_ :== ${lvar call})
         PATTERN
 
-        # rubocop:disable Metrics/AbcSize
         def on_or(node)
-          root_of_or_node = root_of_or_node(node)
-          return unless node == root_of_or_node
+          return unless node == root_of_or_node(node)
           return unless nested_comparison?(node)
-
-          return unless (variable, values = find_offending_var(node))
+          return unless (variable, values, skipped = find_offending_var(node))
           return if values.size < comparisons_threshold
 
           range = offense_range(values)
+          # Bail when an allowed method comparison sits between the collected
+          # values: collapsing them into a single `include?` would drop it.
+          return if skipped_within_range?(skipped, range)
 
           add_offense(range) do |corrector|
-            elements = values.map(&:source).join(', ')
-            argument = variable.lvar_type? ? variable_name(variable) : variable.source
-            prefer_method = "[#{elements}].include?(#{argument})"
-
-            corrector.replace(range, prefer_method)
+            corrector.replace(range, preferred_method(variable, values))
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         private
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        def find_offending_var(node, variables = Set.new, values = [])
+        def skipped_within_range?(skipped, range)
+          skipped.any? { |node_part| range.contains?(node_part.source_range) }
+        end
+
+        def preferred_method(variable, values)
+          elements = values.map(&:source).join(', ')
+          argument = variable.lvar_type? ? variable_name(variable) : variable.source
+          "[#{elements}].include?(#{argument})"
+        end
+
+        def find_offending_var(node, variables = Set.new, values = [], skipped = [])
           if node.or_type?
-            find_offending_var(node.lhs, variables, values)
-            find_offending_var(node.rhs, variables, values)
+            find_offending_var(node.lhs, variables, values, skipped)
+            find_offending_var(node.rhs, variables, values, skipped)
           elsif simple_double_comparison?(node)
             return
-          elsif (var, obj = simple_comparison(node))
-            return if allow_method_comparison? && obj.call_type?
+          elsif (comparison = simple_comparison(node))
+            collect_comparison(node, comparison, variables, values, skipped)
+          end
 
-            variables << var
-            return if variables.size > 1
+          [variables.first, values, skipped] if variables.any?
+        end
 
-            values << obj
+        def collect_comparison(node, comparison, variables, values, skipped)
+          var, obj = comparison
+          if allow_method_comparison? && obj.call_type?
+            skipped << node
+            return
           end
 
-          [variables.first, values] if variables.any?
+          variables << var
+          return if variables.size > 1
+
+          values << obj
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def offense_range(values)
           values.first.parent.source_range.begin.join(values.last.parent.source_range.end)

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

@@ -6,6 +6,14 @@ module RuboCop
       # Checks whether some constant value isn't a
       # mutable literal (e.g. array or hash).
       #
+      # When the `Recursive` option is enabled, mutable literals nested inside
+      # arrays and hashes are also frozen, so an offense on the outermost
+      # unfrozen literal will autocorrect every nested mutable literal as well.
+      # When the outer literal already has `.freeze` appended, the cop descends
+      # into it and reports each outermost unfrozen literal underneath. The
+      # option is disabled by default to preserve existing behavior; opt in to
+      # get strict nested freezing.
+      #
       # Strict mode can be used to freeze all constants, rather than
       # just literals.
       # Strict mode is considered an experimental feature. It has not been
@@ -49,6 +57,17 @@ module RuboCop
       #   CONST = Something.new
       #
       #
+      # @example Recursive: false (default)
+      #   # good - only the outer container needs to be frozen
+      #   CONST = [{ a: [], b: 'foo' }].freeze
+      #
+      # @example Recursive: true
+      #   # bad - nested mutable literals must be frozen too
+      #   CONST = [{ a: [], b: 'foo' }].freeze
+      #
+      #   # good
+      #   CONST = [{ a: [].freeze, b: 'foo'.freeze }.freeze].freeze
+      #
       # @example EnforcedStyle: strict
       #   # bad
       #   CONST = Something.new
@@ -70,6 +89,9 @@ module RuboCop
       #     end
       #   end.freeze
       #
+      #   # good - `Data.define` declares an immutable value type
+      #   CONST = Data.define(:foo, :bar)
+      #
       # @example
       #   # Magic comment - shareable_constant_value: literal
       #
@@ -124,8 +146,15 @@ module RuboCop
 
         MSG = 'Freeze mutable objects assigned to constants.'
 
+        # With `Recursive: true`, `.freeze` is appended to a nested literal. When the literal
+        # is the last element and spans multiple lines, the trailing comma lands between the literal
+        # and the `.freeze` appended in the same pass.
+        def self.autocorrect_incompatible_with
+          [Style::TrailingCommaInArrayLiteral, Style::TrailingCommaInHashLiteral]
+        end
+
         def on_casgn(node)
-          if node.expression.nil? # This is only the case for `CONST += ...` or similarg66
+          if node.expression.nil? # This is only the case for `CONST += ...` or similar
             parent = node.parent
             return unless parent.or_asgn_type? # We only care about `CONST ||= ...`
 
@@ -138,31 +167,55 @@ module RuboCop
         private
 
         def on_assignment(value)
-          if style == :strict
-            strict_check(value)
+          nodes = mutable_nodes(value) do |node|
+            if style == :strict
+              strict_check(node)
+            else
+              literal_check(node)
+            end
+          end
+
+          nodes.each do |node|
+            add_offense(node) { |corrector| autocorrect(corrector, node) }
+          end
+        end
+
+        def mutable_nodes(value, &block)
+          if recursive? && explicitly_frozen_literal?(value)
+            literal_children(value.receiver).flat_map { |c| mutable_nodes(c, &block) }
           else
-            check(value)
+            node_offending = yield(value)
+
+            if node_offending
+              [value]
+            else
+              []
+            end
           end
         end
 
         def strict_check(value)
+          return if value.assignment?
           return if immutable_literal?(value)
           return if operation_produces_immutable_object?(value)
           return if frozen_string_literal?(value)
           return if shareable_constant_value?(value)
+          return if parenthesized_immutable_value?(value)
 
-          add_offense(value) { |corrector| autocorrect(corrector, value) }
+          true
         end
 
-        def check(value)
-          range_enclosed_in_parentheses = range_enclosed_in_parentheses?(value)
-          return unless mutable_literal?(value) ||
-                        (target_ruby_version <= 2.7 && range_enclosed_in_parentheses)
-
+        def literal_check(value)
+          return unless mutable_or_unfrozen_range?(value)
           return if frozen_string_literal?(value)
           return if shareable_constant_value?(value)
 
-          add_offense(value) { |corrector| autocorrect(corrector, value) }
+          true
+        end
+
+        def mutable_or_unfrozen_range?(value)
+          mutable_literal?(value) ||
+            (target_ruby_version <= 2.7 && range_enclosed_in_parentheses?(value))
         end
 
         def autocorrect(corrector, node)
@@ -171,13 +224,66 @@ module RuboCop
           splat_value = splat_value(node)
           if splat_value
             correct_splat_expansion(corrector, expr, splat_value)
-          elsif node.array_type? && !node.bracketed?
+            corrector.insert_after(expr, '.freeze')
+            return
+          end
+
+          if node.array_type? && !node.bracketed?
             corrector.wrap(expr, '[', ']')
           elsif requires_parentheses?(node)
             corrector.wrap(expr, '(', ')')
           end
 
           corrector.insert_after(expr, '.freeze')
+
+          freeze_nested_literals(corrector, node) if recursive?
+        end
+
+        # Recursively freezes every nested mutable literal inside an array or
+        # hash literal. Already-frozen subtrees are not re-frozen, but their
+        # children are still inspected for unfrozen literals deeper down.
+        def freeze_nested_literals(corrector, node)
+          literal_children(node).each do |child|
+            if explicitly_frozen_literal?(child)
+              freeze_nested_literals(corrector, child.receiver)
+            elsif freezable_nested_literal?(child)
+              autocorrect(corrector, child)
+            end
+          end
+        end
+
+        def freezable_nested_literal?(node)
+          return false if frozen_string_literal?(node)
+          return false if shareable_constant_value?(node)
+
+          mutable_literal?(node)
+        end
+
+        # Returns the child literals of an array or hash node that may
+        # themselves need freezing. For hashes, both keys and values are
+        # included. Percent-literal arrays (e.g. `%w(a b)`) are skipped because
+        # `.freeze` cannot be appended to their contents.
+        def literal_children(node)
+          case node.type
+          when :array
+            return [] if node.percent_literal?
+
+            node.children
+          when :hash
+            node.children.flat_map { |child| child.pair_type? ? child.children : [] }
+          else
+            []
+          end
+        end
+
+        def explicitly_frozen_literal?(node)
+          return false unless node.send_type? && node.method?(:freeze)
+
+          node.receiver && mutable_literal?(node.receiver)
+        end
+
+        def recursive?
+          cop_config.fetch('Recursive', false)
         end
 
         def mutable_literal?(value)
@@ -196,12 +302,30 @@ module RuboCop
           recent_shareable_value? node
         end
 
+        def parenthesized_immutable_value?(value)
+          return false if !value.begin_type? || !value.children.one?
+
+          inner = value.children.first
+
+          !inner.assignment? && !strict_check(inner)
+        end
+
         def frozen_regexp_or_range_literals?(node)
           target_ruby_version >= 3.0 && node.type?(:regexp, :range)
         end
 
         def requires_parentheses?(node)
-          node.range_type? || (node.send_type? && node.loc.dot.nil?)
+          if node.range_type? || node.operator_keyword? || unparenthesized_method_call?(node)
+            return true
+          end
+
+          node.if_type? && node.ternary?
+        end
+
+        def unparenthesized_method_call?(node)
+          return false unless node.call_type?
+
+          node.loc.dot.nil? || (node.arguments.any? && !node.parenthesized?)
         end
 
         def correct_splat_expansion(corrector, expr, splat_value)
@@ -225,6 +349,8 @@ module RuboCop
             (const _ _)
             (send (const {nil? cbase} :Struct) :new ...)
             (block (send (const {nil? cbase} :Struct) :new ...) ...)
+            (send (const {nil? cbase} :Data) :define ...)
+            (block (send (const {nil? cbase} :Data) :define ...) ...)
             (send _ :freeze)
             (send {float int} {:+ :- :* :** :/ :% :<<} _)
             (send _ {:+ :- :* :** :/ :%} {float int})

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

@@ -46,7 +46,7 @@ module RuboCop
           @corrected_nodes = nil
         end
 
-        # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity
+        # rubocop:disable-next Metrics/AbcSize,Metrics/CyclomaticComplexity
         def on_if(node)
           return unless if_else?(node)
           return unless (condition = unwrap_begin_nodes(node.condition))
@@ -64,7 +64,6 @@ module RuboCop
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize,Metrics/CyclomaticComplexity
 
         private
 
@@ -119,7 +118,8 @@ module RuboCop
           if node.ternary?
             node.if_branch
           else
-            range_between(node.condition.source_range.end_pos, node.loc.else.begin_pos)
+            if_start = node.loc.begin || node.condition.source_range
+            range_between(if_start.end_pos, node.loc.else.begin_pos)
           end
         end
 

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

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Identifies usages of `arr[arr.length - n]`, `arr[arr.size - n]`, or
+      # `arr[arr.count - n]` and suggests to change them to use `arr[-n]` instead.
+      # Also handles range patterns like `arr[0..(arr.length - n)]`.
+      #
+      # The cop recognizes preserving methods (`sort`, `reverse`, `shuffle`, `rotate`)
+      # and their combinations, allowing safe replacement when the receiver matches.
+      # It works with variables, instance variables, class variables, and constants.
+      #
+      # @safety
+      #   This cop is unsafe because the receiver may not be an Array. For a Hash,
+      #   `hash[hash.size - 1]` looks up the key `hash.size - 1`, which `hash[-1]`
+      #   does not. Even for an Array, `arr[arr.length - n]` wraps around to an
+      #   element from the end when `n` exceeds the length, while `arr[-n]`
+      #   returns `nil`.
+      #
+      # @example
+      #   # bad
+      #   arr[arr.count - 2]
+      #   arr[0..(arr.length - 2)]
+      #   arr[0...(arr.length - 4)]
+      #   arr.sort[arr.reverse.length - 2]
+      #   arr.sort.reverse[arr.sort.size - 2]
+      #
+      #   # good
+      #   arr[-2]
+      #   arr[0..-2]
+      #   arr[0...-4]
+      #   arr.sort[-2]
+      #   arr.sort.reverse[-2]
+      #
+      class NegativeArrayIndex < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Use `%<receiver>s[-%<index>s]` instead of `%<current>s`.'
+        MSG_RANGE = 'Use `%<receiver>s[%<start>s%<range_op>s-%<index>s]` instead of `%<current>s`.'
+        RESTRICT_ON_SEND = %i[[]].freeze
+
+        LENGTH_METHODS = %i[length size count].freeze
+
+        PRESERVING_METHODS = %i[sort reverse shuffle rotate].freeze
+
+        # @!method length_subtraction?(node)
+        def_node_matcher :length_subtraction?, <<~PATTERN
+          (send
+            (send $_ {:length :size :count}) :-
+            (int $_))
+        PATTERN
+
+        def on_send(node)
+          return if node.arguments.empty?
+
+          index_arg = node.first_argument
+          range_node = extract_range_from_begin(index_arg)
+          if range_with_length_subtraction?(range_node, node.receiver)
+            receiver = node.receiver.source
+            return handle_range_pattern(receiver, range_node, index_arg)
+          end
+
+          handle_simple_index_pattern(node, index_arg)
+        end
+
+        alias on_csend on_send
+
+        private
+
+        def handle_simple_index_pattern(node, index_arg)
+          length_receiver, negative_index = length_subtraction?(index_arg)
+
+          return unless negative_index&.positive?
+          return unless receivers_match?(length_receiver, node.receiver)
+
+          add_offense_for_subtraction(node, index_arg, negative_index)
+        end
+
+        def extract_range_from_begin(node)
+          node.begin_type? ? node.children.first : node
+        end
+
+        def extract_inner_end(node)
+          node.children.size == 1 ? node.children.first : node
+        end
+
+        def add_offense_for_subtraction(node, index_arg, negative_index)
+          receiver = node.receiver.source
+          offense_range = index_arg.source_range
+          current = "#{receiver}[#{index_arg.source}]"
+
+          message = format(MSG, receiver: receiver, index: negative_index, current: current)
+
+          add_offense(offense_range, message: message) do |corrector|
+            corrector.replace(offense_range, "-#{negative_index}")
+          end
+        end
+
+        # rubocop:disable-next Metrics/CyclomaticComplexity
+        def range_with_length_subtraction?(range_node, array_receiver)
+          return false unless range_node&.range_type?
+
+          range_end = range_node.end
+          range_start = range_node.begin
+          return false unless range_end && range_start
+
+          return false unless preserving_method?(range_start)
+
+          inner_end = extract_inner_end(range_end)
+          length_receiver, negative_index = length_subtraction?(inner_end)
+
+          return false unless negative_index&.positive?
+
+          receivers_match_strict?(length_receiver, array_receiver)
+        end
+
+        def handle_range_pattern(receiver, range_node, index_arg)
+          range_end = range_node.end
+          inner_end = extract_inner_end(range_end)
+          _length_receiver, negative_index = length_subtraction?(inner_end)
+
+          message, replacement = build_range_offense_data(
+            receiver, range_node, range_end, inner_end, negative_index, index_arg
+          )
+
+          add_offense(range_end, message: message) do |corrector|
+            corrector.replace(index_arg, replacement)
+          end
+        end
+
+        # rubocop:disable-next Metrics/ParameterLists
+        def build_range_offense_data(receiver, range_node, range_end, inner_end, negative_index,
+                                     index_arg)
+          range_op = range_node.erange_type? ? '...' : '..'
+          range_start = range_node.begin.source
+
+          range_without_parens =
+            build_range_without_parens(range_start, range_op, range_end, inner_end)
+          current_source = build_current_source(receiver, range_without_parens, index_arg)
+          start, index = format_range_message_parts(range_start, negative_index, index_arg)
+
+          message = build_message_for_range(receiver, start, range_op, index, current_source)
+          replacement = build_replacement_string(range_start, range_op, negative_index, index_arg)
+
+          [message, replacement]
+        end
+
+        def format_range_message_parts(range_start, negative_index, index_arg)
+          has_parentheses = index_arg.begin_type?
+          start = has_parentheses ? "(#{range_start}" : range_start
+          index = has_parentheses ? "#{negative_index})" : negative_index
+
+          [start, index]
+        end
+
+        def build_message_for_range(receiver, start, range_op, index, current)
+          format(
+            MSG_RANGE,
+            receiver: receiver, start: start, range_op: range_op, index: index, current: current
+          )
+        end
+
+        def build_replacement_string(range_start, range_op, negative_index, index_arg)
+          has_parentheses = index_arg.begin_type?
+
+          if has_parentheses
+            "(#{range_start}#{range_op}-#{negative_index})"
+          else
+            "#{range_start}#{range_op}-#{negative_index}"
+          end
+        end
+
+        def build_current_source(receiver, range_without_parens, index_arg)
+          has_parentheses = index_arg.begin_type?
+
+          if has_parentheses
+            "#{receiver}[(#{range_without_parens})]"
+          else
+            "#{receiver}[#{range_without_parens}]"
+          end
+        end
+
+        def build_range_without_parens(range_start, range_op, range_end, inner_end)
+          end_expression = range_end.begin_type? ? range_end.source : inner_end.source
+
+          "#{range_start}#{range_op}#{end_expression}"
+        end
+
+        def receivers_match?(length_receiver, array_receiver)
+          return array_receiver.self_type? unless length_receiver
+
+          unless preserving_method?(array_receiver) && preserving_method?(length_receiver)
+            return false
+          end
+          return true if length_receiver.source == array_receiver.source
+          return false unless (base_receiver = extract_base_receiver(array_receiver))
+
+          base_receiver.source == (extract_base_receiver(length_receiver) || length_receiver).source
+        end
+
+        def receivers_match_strict?(length_receiver, array_receiver)
+          preserving_method?(array_receiver) &&
+            length_receiver.source == array_receiver.source
+        end
+
+        def extract_base_receiver(node)
+          receiver = node.receiver
+
+          return nil unless receiver
+          return receiver unless receiver.receiver
+
+          extract_base_receiver(receiver)
+        end
+
+        def preserving_method?(node)
+          return true if node.receiver.nil?
+
+          method_name = node.method_name
+          return false unless PRESERVING_METHODS.include?(method_name)
+
+          preserving_method?(node.receiver)
+        end
+      end
+    end
+  end
+end

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

@@ -19,6 +19,19 @@ module RuboCop
 
         MSG = 'Avoid using nested modifiers.'
 
+        # Operands that would otherwise bind differently next to `&&`/`||`, or
+        # not parse at all.
+        # @!method low_precedence?(node)
+        def_node_matcher :low_precedence?, <<~PATTERN
+          {
+            [{and or} semantic_operator?]
+            [send prefix_not?]
+            [if ternary?]
+            assignment?
+            [{csend yield super} arguments? !parenthesized? !operator_method?]
+          }
+        PATTERN
+
         def on_while(node)
           check(node)
         end
@@ -63,25 +76,31 @@ module RuboCop
         end
 
         def left_hand_operand(node, operator)
-          expr = node.condition.source
-          expr = "(#{expr})" if node.condition.or_type? && operator == '&&'
+          expr = operand_source(node.condition)
+          if (node.condition.or_type? && operator == '&&') || low_precedence?(node.condition)
+            expr = "(#{expr})"
+          end
           expr
         end
 
         def right_hand_operand(node, left_hand_keyword)
           condition = node.condition
+          negated = left_hand_keyword != node.keyword
 
-          expr = if condition.send_type? && !condition.arguments.empty? &&
-                    !condition.operator_method?
-                   add_parentheses_to_method_arguments(condition)
-                 else
-                   condition.source
-                 end
-          expr = "(#{expr})" if requires_parens?(condition)
-          expr = "!#{expr}" unless left_hand_keyword == node.keyword
+          expr = operand_source(condition)
+          expr = "(#{expr})" if requires_parens?(condition, negated)
+          expr = "!#{expr}" if negated
           expr
         end
 
+        def operand_source(condition)
+          if condition.send_type? && !condition.arguments.empty? && !condition.operator_method?
+            add_parentheses_to_method_arguments(condition)
+          else
+            condition.source
+          end
+        end
+
         def add_parentheses_to_method_arguments(send_node)
           expr = +''
           expr << "#{send_node.receiver.source}." if send_node.receiver
@@ -91,8 +110,13 @@ module RuboCop
           expr
         end
 
-        def requires_parens?(node)
-          node.or_type? || !(RuboCop::AST::Node::COMPARISON_OPERATORS & node.children).empty?
+        def requires_parens?(node, negated)
+          # A negated `&&`/`||` operand must be wrapped so the `!` applies to the
+          # whole expression (e.g. `!(a && b)`, not `!a && b`).
+          (negated && node.operator_keyword?) ||
+            node.or_type? ||
+            low_precedence?(node) ||
+            !(RuboCop::AST::Node::COMPARISON_OPERATORS & node.children).empty?
         end
       end
     end