rubocop 1.80.2 → 1.86.1

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/magic_comment_format.rb

@@ -176,7 +176,7 @@ module RuboCop
           if first_non_comment_token
             0...first_non_comment_token.line
           else
-            (0..)
+            0..
           end
         end
 
@@ -299,7 +299,7 @@ module RuboCop
         end
 
         def supported_capitalizations
-          cop_config['SupportedCapitalizations'].map(&:to_sym)
+          @supported_capitalizations ||= cop_config['SupportedCapitalizations'].map(&:to_sym).freeze
         end
       end
     end

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

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for `map { |x| x.to_s }.join` and similar calls where the
+      # `map` is redundant because `Array#join` implicitly calls `#to_s` on
+      # each element.
+      #
+      # @safety
+      #   This cop is unsafe because it cannot guarantee that the receiver
+      #   is an `Array` by static analysis. If the receiver does not have
+      #   an `Array#join`-compatible implementation (i.e. one that calls
+      #   `#to_s` on elements), the correction may change behavior.
+      #
+      # @example
+      #   # bad
+      #   array.map(&:to_s).join(', ')
+      #
+      #   # bad
+      #   array.map { |x| x.to_s }.join(', ')
+      #
+      #   # bad
+      #   array.collect(&:to_s).join
+      #
+      #   # good
+      #   array.join(', ')
+      #
+      #   # good
+      #   array.join
+      #
+      class MapJoin < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Remove redundant `%<method>s(&:to_s)` before `join`.'
+        RESTRICT_ON_SEND = %i[join].freeze
+
+        # map(&:to_s).join(...)
+        # @!method map_to_s_join?(node)
+        def_node_matcher :map_to_s_join?, <<~PATTERN
+          (call
+            $(call _ ${:map :collect} (block_pass (sym :to_s)))
+            :join ...)
+        PATTERN
+
+        # map { |x| x.to_s }.join(...)
+        # @!method map_to_s_block_join?(node)
+        def_node_matcher :map_to_s_block_join?, <<~PATTERN
+          (call
+            $(block
+              (call _ ${:map :collect})
+              (args (arg _x))
+              (send (lvar _x) :to_s))
+            :join ...)
+        PATTERN
+
+        # map { _1.to_s }.join(...)
+        # @!method map_to_s_numblock_join?(node)
+        def_node_matcher :map_to_s_numblock_join?, <<~PATTERN
+          (call
+            $(numblock
+              (call _ ${:map :collect})
+              1
+              (send (lvar :_1) :to_s))
+            :join ...)
+        PATTERN
+
+        # map { it.to_s }.join(...)
+        # @!method map_to_s_itblock_join?(node)
+        def_node_matcher :map_to_s_itblock_join?, <<~PATTERN
+          (call
+            $(itblock
+              (call _ ${:map :collect})
+              :it
+              (send (lvar :it) :to_s))
+            :join ...)
+        PATTERN
+
+        def on_send(node)
+          map_to_s_join?(node) { |m, n| register_offense(node, m, n) } ||
+            map_to_s_block_join?(node) { |m, n| register_offense(node, m, n) } ||
+            map_to_s_numblock_join?(node) { |m, n| register_offense(node, m, n) } ||
+            map_to_s_itblock_join?(node) { |m, n| register_offense(node, m, n) }
+        end
+        alias on_csend on_send
+
+        private
+
+        def register_offense(join_node, map_node, method_name)
+          map_send = map_node.any_block_type? ? map_node.send_node : map_node
+          message = format(MSG, method: method_name)
+
+          add_offense(map_send.loc.selector, message: message) do |corrector|
+            remove_map_call(corrector, join_node, map_node, map_send)
+          end
+        end
+
+        def remove_map_call(corrector, join_node, map_node, map_send)
+          receiver = map_send.receiver
+          if receiver
+            corrector.replace(removal_range(receiver, map_node, map_send), '')
+          else
+            corrector.replace(no_receiver_range(map_node, join_node), '')
+          end
+        end
+
+        def removal_range(receiver, map_node, map_send)
+          start_pos = if receiver.last_line < map_send.loc.dot.line
+                        receiver.source_range.end_pos
+                      else
+                        map_send.loc.dot.begin_pos
+                      end
+          range_between(start_pos, map_node.source_range.end_pos)
+        end
+
+        def no_receiver_range(map_node, join_node)
+          range_between(map_node.source_range.begin_pos, join_node.loc.dot.end_pos)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/method_call_with_args_parentheses/require_parentheses.rb

@@ -33,13 +33,26 @@ module RuboCop
           end
 
           def included_macros_list
-            cop_config.fetch('IncludedMacros', []).map(&:to_sym)
+            @included_macros_list ||= cop_config.fetch('IncludedMacros', []).map(&:to_sym).freeze
+          end
+
+          def included_macro_patterns
+            @included_macro_patterns ||=
+              cop_config.fetch('IncludedMacroPatterns', [])
+                        .map { |pattern| Regexp.new(pattern) }.freeze
+          end
+
+          def matches_included_macro_pattern?(method_name)
+            included_macro_patterns.any? do |pattern|
+              pattern.match?(method_name.to_s)
+            end
           end
 
           def ignored_macro?(node)
             cop_config['IgnoreMacros'] &&
               node.macro? &&
-              !included_macros_list.include?(node.method_name)
+              !included_macros_list.include?(node.method_name) &&
+              !matches_included_macro_pattern?(node.method_name)
           end
         end
       end

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

@@ -9,17 +9,20 @@ module RuboCop
       # In the default style (require_parentheses), macro methods are allowed.
       # Additional methods can be added to the `AllowedMethods` or
       # `AllowedPatterns` list. These options are valid only in the default
-      # style. Macros can be included by either setting `IgnoreMacros` to false
-      # or adding specific macros to the `IncludedMacros` list.
+      # style. Macros can be included by either setting `IgnoreMacros` to false,
+      # adding specific macros to the `IncludedMacros` list, or using
+      # `IncludedMacroPatterns` for pattern-based matching.
       #
       # Precedence of options is as follows:
       #
       # 1. `AllowedMethods`
       # 2. `AllowedPatterns`
       # 3. `IncludedMacros`
+      # 4. `IncludedMacroPatterns`
       #
-      # If a method is listed in both `IncludedMacros` and `AllowedMethods`,
-      # then the latter takes precedence (that is, the method is allowed).
+      # If a method is listed in both `IncludedMacros`/`IncludedMacroPatterns`
+      # and `AllowedMethods`, then the latter takes precedence (that is, the
+      # method is allowed).
       #
       # In the alternative style (omit_parentheses), there are three additional
       # options.
@@ -148,6 +151,16 @@ module RuboCop
       #   # still enforces parentheses on other methods
       #   array.delete(e)
       #
+      # @example IncludedMacroPatterns: ["^assert", "^refute"]
+      #
+      #   # bad
+      #   assert_equal 'test', x
+      #   refute_nil value
+      #
+      #   # good
+      #   assert_equal('test', x)
+      #   refute_nil(value)
+      #
       # @example AllowParenthesesInMultilineCall: false (default)
       #
       #   # bad

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

@@ -103,8 +103,6 @@ module RuboCop
         MSG_MISSING = 'Use def with parentheses when there are parameters.'
 
         def on_def(node)
-          return if forced_parentheses?(node)
-
           args = node.arguments
 
           if require_parentheses?(args)
@@ -113,10 +111,10 @@ module RuboCop
             else
               correct_style_detected
             end
+          elsif forced_parentheses?(node)
+            correct_style_detected
           elsif parentheses?(args)
             unwanted_parentheses(args)
-          else
-            correct_style_detected
           end
         end
         alias on_defs on_def

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

@@ -0,0 +1,107 @@
+# 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.
+      #
+      # @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.constants.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.const_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?,
+          constants: :const_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