rubocop 1.71.1 → 1.88.2

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

@@ -0,0 +1,220 @@
+# 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.
+      #
+      # @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
+
+        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 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
+        # rubocop:enable Metrics/ParameterLists
+
+        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
+
+          !extract_base_receiver(array_receiver).nil?
+        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/next.rb

@@ -46,6 +46,38 @@ module RuboCop
       #     next unless a == 1
       #     puts a
       #   end
+      #
+      # @example AllowConsecutiveConditionals: false (default)
+      #   # bad
+      #   [1, 2].each do |a|
+      #     if a == 1
+      #       puts a
+      #     end
+      #     if a == 2
+      #       puts a
+      #     end
+      #   end
+      #
+      #   # good
+      #   [1, 2].each do |a|
+      #     if a == 1
+      #       puts a
+      #     end
+      #     next unless a == 2
+      #     puts a
+      #   end
+      #
+      # @example AllowConsecutiveConditionals: true
+      #   # good
+      #   [1, 2].each do |a|
+      #     if a == 1
+      #       puts a
+      #     end
+      #     if a == 2
+      #       puts a
+      #     end
+      #   end
+      #
       class Next < Base
         include ConfigurableEnforcedStyle
         include MinBodyLength
@@ -72,6 +104,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         def on_while(node)
           check(node)
@@ -86,6 +119,9 @@ module RuboCop
 
           offending_node = offense_node(node.body)
 
+          return if allowed_consecutive_conditionals? &&
+                    consecutive_conditionals?(offending_node)
+
           add_offense(offense_location(offending_node)) do |corrector|
             if offending_node.modifier_form?
               autocorrect_modifier(corrector, offending_node)
@@ -227,6 +263,14 @@ module RuboCop
 
           corrector.remove_leading(buffer.line_range(lineno), adjustment) if adjustment.positive?
         end
+
+        def consecutive_conditionals?(if_node)
+          if_node.parent&.begin_type? && if_node.left_sibling&.if_type?
+        end
+
+        def allowed_consecutive_conditionals?
+          cop_config.fetch('AllowConsecutiveConditionals', false)
+        end
       end
     end
   end

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

@@ -4,9 +4,8 @@ module RuboCop
   module Cop
     module Style
       # Checks for comparison of something with nil using `==` and
-      # `nil?`.
-      #
-      # Supported styles are: predicate, comparison.
+      # `nil?`. Enforcing a consistent style (either the `nil?`
+      # predicate or `==` comparison) improves readability.
       #
       # @example EnforcedStyle: predicate (default)
       #
@@ -43,24 +42,26 @@ module RuboCop
         # @!method nil_check?(node)
         def_node_matcher :nil_check?, '(send _ :nil?)'
 
+        # rubocop:disable Metrics/AbcSize
         def on_send(node)
           return unless node.receiver
 
           style_check?(node) do
             add_offense(node.loc.selector) do |corrector|
-              new_code = if prefer_comparison?
-                           node.source.sub('.nil?', ' == nil')
-                         else
-                           node.source.sub(/\s*={2,3}\s*nil/, '.nil?')
-                         end
-
-              corrector.replace(node, new_code)
+              if prefer_comparison?
+                range = node.loc.dot.join(node.loc.selector.end)
+                corrector.replace(range, ' == nil')
+              else
+                range = node.receiver.source_range.end.join(node.source_range.end)
+                corrector.replace(range, '.nil?')
+              end
 
               parent = node.parent
               corrector.wrap(node, '(', ')') if parent.respond_to?(:method?) && parent.method?(:!)
             end
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         private
 

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

@@ -6,6 +6,11 @@ module RuboCop
       # Checks for lambdas and procs that always return nil,
       # which can be replaced with an empty lambda or proc instead.
       #
+      # NOTE: A `proc` that returns nil via an explicit `return` is allowed,
+      # because in a `proc` `return` exits the enclosing method, so removing it
+      # would change behavior. A lambda is still reported, since there `return`
+      # only exits the lambda itself.
+      #
       # @example
       #   # bad
       #   -> { nil }
@@ -43,9 +48,12 @@ module RuboCop
           { ({return next break} nil) (nil) }
         PATTERN
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
           return unless node.lambda_or_proc?
           return unless nil_return?(node.body)
+          # `return` inside a non-lambda proc returns from the enclosing method,
+          # so dropping it changes behavior; only a lambda can omit it safely.
+          return if node.body.return_type? && !node.lambda?
 
           message = format(MSG, type: node.lambda? ? 'lambda' : 'proc')
           add_offense(node, message: message) do |corrector|

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

@@ -121,17 +121,11 @@ module RuboCop
         end
 
         def autocorrect_comparison(corrector, node)
-          expr = node.source
-
-          new_code = if include_semantic_changes?
-                       expr.sub(/\s*!=\s*nil/, '')
-                     else
-                       expr.sub(/^(\S*)\s*!=\s*nil/, '!\1.nil?')
-                     end
-
-          return if expr == new_code
-
-          corrector.replace(node, new_code)
+          if include_semantic_changes?
+            corrector.replace(node, node.receiver.source)
+          else
+            corrector.replace(node, "!#{node.receiver.source}.nil?")
+          end
         end
 
         def autocorrect_non_nil(corrector, node, inner_node)

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

@@ -4,6 +4,8 @@ module RuboCop
   module Cop
     module Style
       # Checks for uses of the keyword `not` instead of `!`.
+      # The `not` keyword has lower precedence than `!`, which can
+      # lead to surprising behavior and often requires parentheses.
       #
       # @example
       #

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

@@ -4,7 +4,8 @@ module RuboCop
   module Cop
     module Style
       # Checks for big numeric literals without `_` between groups
-      # of digits in them.
+      # of digits in them. Underscores make large numbers easier to
+      # read by visually separating groups of digits.
       #
       # Additional allowed patterns can be added by adding regexps to
       # the `AllowedPatterns` configuration. All regexps are treated
@@ -116,7 +117,7 @@ module RuboCop
         end
 
         def allowed_numbers
-          cop_config.fetch('AllowedNumbers', []).map(&:to_s)
+          @allowed_numbers ||= cop_config.fetch('AllowedNumbers', []).map(&:to_s).freeze
         end
 
         def allowed_patterns

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

@@ -92,7 +92,7 @@ module RuboCop
           return unless numeric
 
           return if allowed_method_name?(node.method_name) ||
-                    node.each_ancestor(:send, :block).any? do |ancestor|
+                    node.each_ancestor(:send, :any_block).any? do |ancestor|
                       allowed_method_name?(ancestor.method_name)
                     end
 

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

@@ -38,6 +38,7 @@ module RuboCop
           check_method_node(node.send_node)
         end
         alias on_numblock on_block
+        alias on_itblock on_block
 
         def on_send(node)
           return unless node.arguments.one? && node.first_argument.block_pass_type?

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

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks that each source file defines at most one top-level class or module.
+      #
+      # Keeping one class or module per file makes it easier to find and navigate
+      # code, and follows the convention used by most Ruby projects.
+      #
+      # Classes and modules listed in `AllowedClasses` are not counted toward the
+      # limit. This is useful for small ancillary classes like custom exception
+      # classes that logically belong with the main class.
+      #
+      # @example
+      #   # bad - Multiple top-level classes
+      #   class Foo
+      #   end
+      #
+      #   class Bar
+      #   end
+      #
+      #   # bad - Multiple top-level modules
+      #   module Foo
+      #   end
+      #
+      #   module Bar
+      #   end
+      #
+      #   # bad - A top-level class and a top-level module
+      #   class Foo
+      #   end
+      #
+      #   module Bar
+      #   end
+      #
+      #   # good - A single top-level class
+      #   class Foo
+      #   end
+      #
+      #   # good - A single top-level module
+      #   module Foo
+      #   end
+      #
+      #   # good - Nested classes within a single top-level class
+      #   class Foo
+      #     class Bar
+      #     end
+      #   end
+      #
+      #   # good - Multiple classes within a single top-level module
+      #   module Foo
+      #     class Bar
+      #     end
+      #
+      #     class Baz
+      #     end
+      #   end
+      #
+      # @example AllowedClasses: ['AllowedClass']
+      #   # good
+      #   class Foo
+      #   end
+      #
+      #   class AllowedClass
+      #   end
+      #
+      class OneClassPerFile < Base
+        include RangeHelp
+
+        MSG = 'Do not define multiple classes/modules at the top level in a single file.'
+
+        def on_new_investigation
+          @top_level_definitions = []
+        end
+
+        def on_class(node)
+          check_top_level(node)
+        end
+
+        def on_module(node)
+          check_top_level(node)
+        end
+
+        private
+
+        def check_top_level(node)
+          return unless top_level_definition?(node)
+          return if allowed_class?(node)
+
+          @top_level_definitions << node
+          return unless @top_level_definitions.length > 1
+
+          add_offense(range_between(node.source_range.begin_pos, node.loc.name.end_pos))
+        end
+
+        def top_level_definition?(node)
+          if node.parent&.begin_type?
+            node.parent.root?
+          else
+            node.root?
+          end
+        end
+
+        def allowed_class?(node)
+          allowed_classes.include?(node.identifier.short_name)
+        end
+
+        def allowed_classes
+          @allowed_classes ||= cop_config.fetch('AllowedClasses', []).map(&:intern)
+        end
+      end
+    end
+  end
+end

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

@@ -3,9 +3,10 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for uses of if/then/else/end constructs on a single line.
-      # `AlwaysCorrectToMultiline` config option can be set to true to autocorrect all offenses to
-      # multi-line constructs. When `AlwaysCorrectToMultiline` is false (default case) the
+      # Checks for uses of `if/then/else/end` constructs on a single line.
+      # A ternary operator (`?:`) or multi-line `if` is more readable.
+      # `AlwaysCorrectToMultiline` config option can be set to `true` to autocorrect all offenses to
+      # multi-line constructs. When `AlwaysCorrectToMultiline` is `false` (default case) the
       # autocorrect will first try converting them to ternary operators.
       #
       # @example
@@ -55,19 +56,21 @@ module RuboCop
         include OnNormalIfUnless
         extend AutoCorrector
 
-        MSG = 'Favor the ternary operator (`?:`) or multi-line constructs ' \
-              'over single-line `%<keyword>s/then/else/end` constructs.'
+        MSG_SUFFIX = 'over single-line `%<keyword>s/then/else/end` constructs.'
+        MSG_TERNARY = "Favor the ternary operator (`?:`) #{MSG_SUFFIX}"
+        MSG_MULTILINE = "Favor multi-line `%<keyword>s` #{MSG_SUFFIX}"
 
         def on_normal_if_unless(node)
           return unless node.single_line?
           return unless node.else_branch
           return if node.elsif? || node.if_branch&.begin_type?
 
-          message = message(node)
-          add_offense(node, message: message) do |corrector|
+          multiline = multiline?(node)
+
+          add_offense(node, message: message(node, multiline)) do |corrector|
             next if part_of_ignored_node?(node)
 
-            autocorrect(corrector, node)
+            autocorrect(corrector, node, multiline)
 
             ignore_node(node)
           end
@@ -75,12 +78,18 @@ module RuboCop
 
         private
 
-        def message(node)
-          format(MSG, keyword: node.keyword)
+        def multiline?(node)
+          always_multiline? || cannot_replace_to_ternary?(node)
+        end
+
+        def message(node, multiline)
+          template = multiline ? MSG_MULTILINE : MSG_TERNARY
+
+          format(template, keyword: node.keyword)
         end
 
-        def autocorrect(corrector, node)
-          if always_multiline? || cannot_replace_to_ternary?(node)
+        def autocorrect(corrector, node, multiline)
+          if multiline
             IfThenCorrector.new(node, indentation: configured_indentation_width).call(corrector)
           else
             corrector.replace(node, ternary_correction(node))

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

@@ -61,7 +61,7 @@ module RuboCop
         def custom_class_or_module_definition?(node)
           parent = node.parent
 
-          parent.type?(:class, :module) && node.left_siblings.empty?
+          parent&.type?(:class, :module) && node.left_siblings.empty?
         end
       end
     end

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

@@ -26,9 +26,10 @@ module RuboCop
           splat kwsplat forwarded_args forwarded_restarg forwarded_kwrestarg block_pass
         ].freeze
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_send(node)
           return unless (dot = node.loc.dot)
+          return if unary_method_no_operator?(node)
           return if node.receiver.const_type? || !node.arguments.one?
 
           return unless (rhs = node.first_argument)
@@ -43,10 +44,18 @@ module RuboCop
             corrector.insert_after(selector, ' ') if insert_space_after?(node)
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         private
 
+        # `foo.~@` and `foo.!@` call the method `~` and `!` respectively. While those
+        # are operator methods, we don't want to actually consider them as such.
+        def unary_method_no_operator?(node)
+          return false unless node.nonmutating_unary_operator_method?
+
+          node.method_name.to_s != node.selector.source
+        end
+
         # Checks for an acceptable case of `foo.+(bar).baz`.
         def method_call_with_parenthesized_arg?(argument)
           return false unless argument.parent.parent&.send_type?

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

@@ -46,7 +46,7 @@ module RuboCop
         end
 
         def super_used?(node)
-          node.parent.each_node(:zsuper).any?
+          node.parent.each_node(:zsuper, :super).any?
         end
       end
     end

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

@@ -27,6 +27,7 @@ module RuboCop
         def on_def(node)
           each_misplaced_optional_arg(node.arguments) { |argument| add_offense(argument) }
         end
+        alias on_defs on_def
 
         private