rubocop 1.82.0 → 1.84.0

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

@@ -8,20 +8,20 @@ module RuboCop
       #
       # @example
       #
-      #  # bad
-      #  tired? ? 'stop' : 'go faster' if running?
+      #   # bad
+      #   tired? ? 'stop' : 'go faster' if running?
       #
-      #  # bad
-      #  if tired?
-      #    "please stop"
-      #  else
-      #    "keep going"
-      #  end if running?
+      #   # bad
+      #   if tired?
+      #     "please stop"
+      #   else
+      #     "keep going"
+      #   end if running?
       #
-      #  # good
-      #  if running?
-      #    tired? ? 'stop' : 'go faster'
-      #  end
+      #   # good
+      #   if running?
+      #     tired? ? 'stop' : 'go faster'
+      #   end
       class IfUnlessModifierOfIfUnless < Base
         include StatementModifier
         extend AutoCorrector

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

@@ -6,18 +6,18 @@ module RuboCop
       # Checks for use of the lambda.(args) syntax.
       #
       # @example EnforcedStyle: call (default)
-      #  # bad
-      #  lambda.(x, y)
+      #   # bad
+      #   lambda.(x, y)
       #
-      #  # good
-      #  lambda.call(x, y)
+      #   # good
+      #   lambda.call(x, y)
       #
       # @example EnforcedStyle: braces
-      #  # bad
-      #  lambda.call(x, y)
+      #   # bad
+      #   lambda.call(x, y)
       #
-      #  # good
-      #  lambda.(x, y)
+      #   # good
+      #   lambda.(x, y)
       class LambdaCall < Base
         include ConfigurableEnforcedStyle
         extend AutoCorrector

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

@@ -26,33 +26,65 @@ module RuboCop
       #
       #   Array.method_defined?(:find, false)
       #
+      #   # bad
+      #   Array.class_variables.include?(:foo)
+      #   Array.constants.include?(:foo)
+      #   Array.private_instance_methods.include?(:foo)
+      #   Array.protected_instance_methods.include?(:foo)
+      #   Array.public_instance_methods.include?(:foo)
+      #   Array.included_modules.include?(:foo)
+      #
+      #   # good
+      #   Array.class_variable_defined?(:foo)
+      #   Array.const_defined?(:foo)
+      #   Array.private_method_defined?(:foo)
+      #   Array.protected_method_defined?(:foo)
+      #   Array.public_method_defined?(:foo)
+      #   Array.include?(:foo)
+      #
+      #  @example AllowedMethods: [included_modules]
+      #
+      #   # good
+      #   Array.included_modules.include?(:foo)
+      #
       class ModuleMemberExistenceCheck < Base
+        include AllowedMethods
         extend AutoCorrector
 
         MSG = 'Use `%<replacement>s` instead.'
 
-        RESTRICT_ON_SEND = %i[instance_methods].freeze
-
-        # @!method instance_methods_inclusion?(node)
-        def_node_matcher :instance_methods_inclusion?, <<~PATTERN
+        # @!method module_member_inclusion?(node)
+        def_node_matcher :module_member_inclusion?, <<~PATTERN
           (call
-            (call _ :instance_methods _?)
+            {(call _ %METHODS_WITH_INHERIT_PARAM _?) (call _ %METHODS_WITHOUT_INHERIT_PARAM)}
             {:include? :member?}
             _)
         PATTERN
 
-        def on_send(node) # rubocop:disable Metrics/AbcSize
+        METHOD_REPLACEMENTS = {
+          class_variables: :class_variable_defined?,
+          constants: :const_defined?,
+          included_modules: :include?,
+          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, :included_modules].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 instance_methods_inclusion?(parent)
+          return unless module_member_inclusion?(parent)
           return unless simple_method_argument?(node) && simple_method_argument?(parent)
+          return if allowed_method?(node.method_name)
 
           offense_range = node.location.selector.join(parent.source_range.end)
-          replacement =
-            if node.first_argument.nil? || node.first_argument.true_type?
-              "method_defined?(#{parent.first_argument.source})"
-            else
-              "method_defined?(#{parent.first_argument.source}, #{node.first_argument.source})"
-            end
+          replacement = replacement_for(node, parent)
 
           add_offense(offense_range, message: format(MSG, replacement: replacement)) do |corrector|
             corrector.replace(offense_range, replacement)
@@ -62,6 +94,17 @@ module RuboCop
 
         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?

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
 

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

@@ -0,0 +1,218 @@
+# 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)
+          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/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/preferred_hash_methods.rb

@@ -14,22 +14,22 @@ module RuboCop
       #   is a `Hash` or responds to the replacement methods.
       #
       # @example EnforcedStyle: short (default)
-      #  # bad
-      #  Hash#has_key?
-      #  Hash#has_value?
+      #   # bad
+      #   Hash#has_key?
+      #   Hash#has_value?
       #
-      #  # good
-      #  Hash#key?
-      #  Hash#value?
+      #   # good
+      #   Hash#key?
+      #   Hash#value?
       #
       # @example EnforcedStyle: verbose
-      #  # bad
-      #  Hash#key?
-      #  Hash#value?
+      #   # bad
+      #   Hash#key?
+      #   Hash#value?
       #
-      #  # good
-      #  Hash#has_key?
-      #  Hash#has_value?
+      #   # good
+      #   Hash#has_key?
+      #   Hash#has_value?
       class PreferredHashMethods < Base
         include ConfigurableEnforcedStyle
         extend AutoCorrector

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

@@ -200,7 +200,7 @@ module RuboCop
         end
 
         def asgn_type?(node)
-          node.type?(:lvasgn, :ivasgn, :cvasgn, :gvasgn)
+          node.type?(:lvasgn, :ivasgn, :cvasgn, :gvasgn, :casgn)
         end
 
         def branches_have_method?(node)

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Identifies places where `array.reverse.find` can be replaced by `array.rfind`.
+      #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   is an `Array` or responds to the replacement method.
+      #
+      # @example
+      #   # bad
+      #   array.reverse.find { |item| item.even? }
+      #   array.reverse.detect { |item| item.even? }
+      #   array.reverse_each.find { |item| item.even? }
+      #   array.reverse_each.detect { |item| item.even? }
+      #
+      #   # good
+      #   array.rfind { |item| item.even? }
+      #
+      class ReverseFind < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        MSG = 'Use `rfind` instead.'
+        RESTRICT_ON_SEND = %i[find detect].freeze
+
+        minimum_target_ruby_version 4.0
+
+        # @!method reverse_find?(node)
+        def_node_matcher :reverse_find?, <<~PATTERN
+          (call
+            (call
+              _ {:reverse :reverse_each}) {:find :detect} (block_pass sym)?)
+        PATTERN
+
+        def on_send(node)
+          return unless reverse_find?(node)
+
+          range = node.children.first.loc.selector.join(node.loc.selector)
+
+          add_offense(range) do |corrector|
+            corrector.replace(range, 'rfind')
+          end
+        end
+        alias on_csend on_send
+      end
+    end
+  end
+end

data/lib/rubocop/cop/team.rb

@@ -211,10 +211,10 @@ module RuboCop
 
         each_corrector(report) do |to_merge|
           suppress_clobbering do
-            if offset.positive?
-              corrector.import!(to_merge, offset: offset)
-            else
+            if corrector.source_buffer == to_merge.source_buffer
               corrector.merge!(to_merge)
+            else
+              corrector.import!(to_merge, offset: offset)
             end
           end
         end

data/lib/rubocop/cop/variable_force/branch.rb

@@ -254,8 +254,8 @@ module RuboCop
           end
         end
 
-        # Mix-in module for logical operator control structures.
-        module LogicalOperator
+        # Mix-in module for operator control structures.
+        module Operator
           def always_run?
             left_body?
           end
@@ -263,7 +263,15 @@ module RuboCop
 
         # left_body && right_body
         class And < Base
-          include LogicalOperator
+          include Operator
+
+          define_predicate :left_body?,  child_index: 0
+          define_predicate :right_body?, child_index: 1
+        end
+
+        # left_body &&= right_body
+        class AndAsgn < Base
+          include Operator
 
           define_predicate :left_body?,  child_index: 0
           define_predicate :right_body?, child_index: 1
@@ -271,7 +279,23 @@ module RuboCop
 
         # left_body || right_body
         class Or < Base
-          include LogicalOperator
+          include Operator
+
+          define_predicate :left_body?,  child_index: 0
+          define_predicate :right_body?, child_index: 1
+        end
+
+        # left_body ||= right_body
+        class OrAsgn < Base
+          include Operator
+
+          define_predicate :left_body?,  child_index: 0
+          define_predicate :right_body?, child_index: 1
+        end
+
+        # e.g. left_body += right_body
+        class OpAsgn < Base
+          include Operator
 
           define_predicate :left_body?,  child_index: 0
           define_predicate :right_body?, child_index: 1

data/lib/rubocop/formatter/clang_style_formatter.rb

@@ -47,8 +47,11 @@ module RuboCop
       def report_highlighted_area(highlighted_area)
         space_area  = highlighted_area.source_buffer.slice(0...highlighted_area.begin_pos)
         source_area = highlighted_area.source
-        output.puts("#{' ' * Unicode::DisplayWidth.of(space_area)}" \
-                    "#{'^' * Unicode::DisplayWidth.of(source_area)}")
+        output.puts("#{to_whitespace(space_area)}#{'^' * Unicode::DisplayWidth.of(source_area)}")
+      end
+
+      def to_whitespace(string)
+        "#{string.delete("^\t")}#{' ' * Unicode::DisplayWidth.of(string.delete("\t"))}"
       end
     end
   end

data/lib/rubocop/formatter/formatter_set.rb

@@ -86,7 +86,7 @@ module RuboCop
 
       def builtin_formatter_class(specified_key)
         matching_keys = BUILTIN_FORMATTERS_FOR_KEYS.keys.select do |key|
-          /^\[#{specified_key}\]/.match?(key) || specified_key == key.delete('[]')
+          key.start_with?("[#{specified_key}]") || specified_key == key.delete('[]')
         end
 
         if matching_keys.empty?

data/lib/rubocop/formatter/tap_formatter.rb

@@ -39,8 +39,11 @@ module RuboCop
       def report_highlighted_area(highlighted_area)
         space_area  = highlighted_area.source_buffer.slice(0...highlighted_area.begin_pos)
         source_area = highlighted_area.source
-        output.puts("# #{' ' * Unicode::DisplayWidth.of(space_area)}" \
-                    "#{'^' * Unicode::DisplayWidth.of(source_area)}")
+        output.puts("# #{to_whitespace(space_area)}#{'^' * Unicode::DisplayWidth.of(source_area)}")
+      end
+
+      def to_whitespace(string)
+        "#{string.delete("^\t")}#{' ' * Unicode::DisplayWidth.of(string.delete("\t"))}"
       end
 
       def report_offense(file, offense)

data/lib/rubocop/remote_config.rb

@@ -81,7 +81,7 @@ module RuboCop
     end
 
     def cache_path
-      @cache_path ||= File.expand_path(".rubocop-remote-#{cache_name_from_uri}", @cache_root)
+      @cache_path ||= File.expand_path(cache_name_from_uri, @cache_root)
     end
 
     def cache_path_exists?
@@ -98,7 +98,10 @@ module RuboCop
     end
 
     def cache_name_from_uri
-      "#{Digest::MD5.hexdigest(@uri.to_s)}.yml"
+      # The md5 checksum suffix is 37 bytes, so we play it save and
+      # allow 254 bytes total - this should be safe on Linux/macOS/Windows
+      filename = File.basename(@uri.path).gsub(/\.ya?ml\z/i, '').byteslice(0, 217).scrub('')
+      "#{filename}-#{Digest::MD5.hexdigest(@uri.to_s)}.yml"
     end
 
     def cloned_url