rubocop 1.79.2 → 1.87.0

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

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for usage of `Module` methods returning arrays that can be replaced
+      # with equivalent predicates.
+      #
+      # Calling a method returning an array then checking if an element is inside
+      # it is much slower than using an equivalent predicate method. For example,
+      # `instance_methods.include?` will return an array of all public and protected
+      # instance methods in the module, then check if a given method is inside that
+      # array, while `method_defined?` will do direct method lookup, which is much
+      # faster and consumes less memory.
+      #
+      # NOTE: `constants.include?` is not handled by this cop because
+      # `Module#const_defined?` has different lookup behavior than
+      # `Module#constants` - `const_defined?` searches up to `Object`
+      # (top-level constants like `String`, `Integer`, etc.) while
+      # `constants` does not, which can cause behavior changes after autocorrection.
+      #
+      # @example
+      #   # bad
+      #   Array.instance_methods.include?(:size)
+      #   Array.instance_methods.member?(:size)
+      #   Array.instance_methods(true).include?(:size)
+      #
+      #   Array.instance_methods(false).include?(:find)
+      #
+      #   # good
+      #   Array.method_defined?(:size)
+      #
+      #   Array.method_defined?(:find, false)
+      #
+      #   # bad
+      #   Array.class_variables.include?(:foo)
+      #   Array.private_instance_methods.include?(:foo)
+      #   Array.protected_instance_methods.include?(:foo)
+      #   Array.public_instance_methods.include?(:foo)
+      #
+      #   # good
+      #   Array.class_variable_defined?(:foo)
+      #   Array.private_method_defined?(:foo)
+      #   Array.protected_method_defined?(:foo)
+      #   Array.public_method_defined?(:foo)
+      #
+      class ModuleMemberExistenceCheck < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<replacement>s` instead.'
+
+        # @!method module_member_inclusion?(node)
+        def_node_matcher :module_member_inclusion?, <<~PATTERN
+          (call
+            {(call _ %METHODS_WITH_INHERIT_PARAM _?) (call _ %METHODS_WITHOUT_INHERIT_PARAM)}
+            {:include? :member?}
+            _)
+        PATTERN
+
+        METHOD_REPLACEMENTS = {
+          class_variables: :class_variable_defined?,
+          instance_methods: :method_defined?,
+          private_instance_methods: :private_method_defined?,
+          protected_instance_methods: :protected_method_defined?,
+          public_instance_methods: :public_method_defined?
+        }.freeze
+
+        METHODS_WITHOUT_INHERIT_PARAM = Set[:class_variables].freeze
+        METHODS_WITH_INHERIT_PARAM =
+          (METHOD_REPLACEMENTS.keys.to_set - METHODS_WITHOUT_INHERIT_PARAM).freeze
+
+        RESTRICT_ON_SEND = METHOD_REPLACEMENTS.keys.freeze
+
+        def on_send(node)
+          return unless (parent = node.parent)
+          return unless module_member_inclusion?(parent)
+          return unless simple_method_argument?(node) && simple_method_argument?(parent)
+
+          offense_range = node.location.selector.join(parent.source_range.end)
+          replacement = replacement_for(node, parent)
+
+          add_offense(offense_range, message: format(MSG, replacement: replacement)) do |corrector|
+            corrector.replace(offense_range, replacement)
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def replacement_for(node, parent)
+          replacement_method = METHOD_REPLACEMENTS.fetch(node.method_name)
+          without_inherit_param = METHODS_WITHOUT_INHERIT_PARAM.include?(node.method_name)
+
+          if without_inherit_param || node.first_argument.nil? || node.first_argument.true_type?
+            "#{replacement_method}(#{parent.first_argument.source})"
+          else
+            "#{replacement_method}(#{parent.first_argument.source}, #{node.first_argument.source})"
+          end
+        end
+
+        def simple_method_argument?(node)
+          return false if node.splat_argument? || node.block_argument?
+          return false if node.first_argument&.hash_type?
+
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,9 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for uses of the `then` keyword in multi-line if statements.
+      # Checks for uses of the `then` keyword in multi-line `if` statements.
+      # In multi-line `if` statements, `then` is redundant because the newline
+      # already separates the condition from the body.
       #
       # @example
       #   # bad
@@ -21,8 +23,6 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        NON_MODIFIER_THEN = /then\s*(#.*)?$/.freeze
-
         MSG = 'Do not use `then` for multi-line `%<keyword>s`.'
 
         def on_normal_if_unless(node)
@@ -36,7 +36,7 @@ module RuboCop
         private
 
         def non_modifier_then?(node)
-          NON_MODIFIER_THEN.match?(node.loc.begin&.source_line)
+          node.then? && node.loc.begin.line != node.if_branch&.loc&.line
         end
       end
     end

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

@@ -75,6 +75,8 @@ module RuboCop
         end
 
         def correction_exceeds_max_line_length?(node)
+          return false unless max_line_length
+
           indentation_width(node) + definition_width(node) > max_line_length
         end
 
@@ -85,10 +87,6 @@ module RuboCop
         def definition_width(node)
           node.source_range.begin.join(node.arguments.source_range.end).length
         end
-
-        def max_line_length
-          config.for_cop('Layout/LineLength')['Max'] || 120
-        end
       end
     end
   end

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

@@ -125,7 +125,7 @@ module RuboCop
         MSG = 'Freeze mutable objects assigned to constants.'
 
         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 ||= ...`
 

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/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

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

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/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))