rubocop 1.71.1 → 1.92.1

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.
@@ -132,6 +135,32 @@ module RuboCop
       #     bar :baz
       #   end
       #
+      # @example AllowedMethods: ["puts", "print"]
+      #
+      #   # good
+      #   puts "Hello world"
+      #   print "Hello world"
+      #   # still enforces parentheses on other methods
+      #   array.delete(e)
+      #
+      # @example AllowedPatterns: ["^assert"]
+      #
+      #   # good
+      #   assert_equal 'test', x
+      #   assert_match(/foo/, bar)
+      #   # 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
@@ -213,7 +242,13 @@ module RuboCop
         extend AutoCorrector
 
         def self.autocorrect_incompatible_with
-          [Style::NestedParenthesizedCalls, Style::RescueModifier]
+          [
+            Style::NestedParenthesizedCalls,
+            Style::RedundantParentheses,
+            Style::RescueModifier,
+            Style::TernaryParentheses,
+            Style::TrailingCommaInArguments
+          ]
         end
 
         def on_send(node)
@@ -240,7 +275,24 @@ module RuboCop
           return false unless node.arguments.one?
 
           first_node = node.first_argument
-          first_node.begin_type? && first_node.parenthesized_call?
+          return false unless first_node.begin_type? && first_node.parenthesized_call?
+
+          first_node.children.one? && mergeable_parentheses?(first_node.children.first)
+        end
+
+        def mergeable_parentheses?(node)
+          case node.type
+          when :and, :or
+            !node.semantic_operator?
+          when :if, :while, :until
+            !node.modifier_form?
+          when :send
+            !node.keyword?
+          when :rescue, :masgn, :match_pattern, :match_pattern_p
+            false
+          else
+            true
+          end
         end
       end
     end

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

@@ -29,11 +29,17 @@ module RuboCop
       class MethodCallWithoutArgsParentheses < Base
         include AllowedMethods
         include AllowedPattern
+        include ReparsedEquivalence
         extend AutoCorrector
 
         MSG = 'Do not use parentheses for method calls with no arguments.'
 
-        # rubocop:disable Metrics/CyclomaticComplexity
+        def on_new_investigation
+          @pending_ranges = []
+          super
+        end
+
+        # rubocop:disable-next Metrics/CyclomaticComplexity
         def on_send(node)
           return unless !node.arguments? && node.parenthesized?
           return if ineligible_node?(node)
@@ -44,16 +50,34 @@ module RuboCop
 
           register_offense(node)
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
         alias on_csend on_send
 
+        # The parentheses are significant when removing them changes how the
+        # code parses, e.g. when a local variable with the same name is in
+        # scope (`foo = 1; foo()`) or an operator follows (`foo() -1`). The
+        # candidates are verified together, since outside a method definition
+        # each one would otherwise reparse the whole file.
+        def on_investigation_end
+          verified_by_reparse(@pending_ranges).each do |range|
+            add_offense(range) do |corrector|
+              apply_reparse_correction(corrector, range)
+            end
+          end
+
+          super
+        end
+
         private
 
         def register_offense(node)
-          add_offense(offense_range(node)) do |corrector|
-            corrector.remove(node.loc.begin)
-            corrector.remove(node.loc.end)
-          end
+          range = offense_range(node)
+          return if processed_source.contains_comment?(range)
+
+          @pending_ranges << range
+        end
+
+        def apply_reparse_correction(corrector, range)
+          corrector.remove(range)
         end
 
         def ineligible_node?(node)
@@ -88,8 +112,12 @@ module RuboCop
         #
         def parenthesized_it_method_in_block?(node)
           return false unless node.method?(:it)
-          return false unless (block_node = node.each_ancestor(:block).first)
-          return false unless block_node.arguments.empty_and_without_delimiters?
+          return false unless (block_node = node.each_ancestor(:any_block).first)
+          # Inside a numbered/`it` block, a bare `it` is a parse error (it conflicts
+          # with the implicit parameter), so `it()` must keep its parentheses.
+          if block_node.block_type? && !block_node.arguments.empty_and_without_delimiters?
+            return false
+          end
 
           !node.receiver && node.arguments.empty? && !node.block_literal?
         end

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

@@ -36,12 +36,13 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         def on_send(node)
           return if ignored_node?(node)
 
           return unless (receiver = node.receiver)
-          return unless receiver.any_block_type? && receiver.loc.end.is?('end')
+          return unless receiver.any_block_type? && receiver.keywords?
 
           range = range_between(receiver.loc.end.begin_pos, node.source_range.end_pos)
 

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

@@ -102,9 +102,11 @@ module RuboCop
         MSG_PRESENT = 'Use def without parentheses.'
         MSG_MISSING = 'Use def with parentheses when there are parameters.'
 
-        def on_def(node)
-          return if forced_parentheses?(node)
+        def self.autocorrect_incompatible_with
+          [Style::ArgumentsForwarding]
+        end
 
+        def on_def(node)
           args = node.arguments
 
           if require_parentheses?(args)
@@ -113,10 +115,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
@@ -125,7 +127,19 @@ module RuboCop
 
         def correct_arguments(arg_node, corrector)
           corrector.replace(arg_node.loc.begin, ' ')
-          corrector.remove(arg_node.loc.end)
+
+          if code_after_arguments?(arg_node)
+            corrector.replace(arg_node.loc.end, ';')
+          else
+            corrector.remove(arg_node.loc.end)
+          end
+        end
+
+        def code_after_arguments?(arg_node)
+          closing = arg_node.loc.end
+          rest = closing.source_line[(closing.column + 1)..].strip
+
+          !rest.empty? && !rest.start_with?(';', '#')
         end
 
         def forced_parentheses?(node)
@@ -135,8 +149,11 @@ module RuboCop
           # 3. Argument lists containing an anonymous rest arguments forwarding (`*`)
           # 4. Argument lists containing an anonymous keyword rest arguments forwarding (`**`)
           # 5. Argument lists containing an anonymous block forwarding (`&`)
-          # Removing the parens would be a syntax error here.
-          node.endless? || anonymous_arguments?(node)
+          # 6. Argument lists that begin on a line below the method name
+          # 7. Argument lists that begin with a destructuring parameter (`(a, b)`)
+          # Removing the parens would be a syntax error, or a change of the parameters, here.
+          node.endless? || anonymous_arguments?(node) || arguments_on_own_line?(node) ||
+            destructuring_first_argument?(node)
         end
 
         def require_parentheses?(args)
@@ -168,12 +185,23 @@ module RuboCop
 
         def anonymous_arguments?(node)
           return true if node.arguments.any? do |arg|
-            arg.type?(:forward_arg, :restarg, :kwrestarg)
+            arg.forward_arg_type? || (arg.type?(:restarg, :kwrestarg) && arg.name.nil?)
           end
           return false unless (last_argument = node.last_argument)
 
           last_argument.blockarg_type? && last_argument.name.nil?
         end
+
+        def arguments_on_own_line?(node)
+          return false unless (first_argument = node.first_argument)
+          return false unless parentheses?(node.arguments)
+
+          node.arguments.loc.begin.line != first_argument.first_line
+        end
+
+        def destructuring_first_argument?(node)
+          node.first_argument&.mlhs_type?
+        end
       end
     end
   end

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

@@ -6,7 +6,7 @@ module RuboCop
       # Enforces the use of `max` or `min` instead of comparison for greater or less.
       #
       # NOTE: It can be used if you want to present limit or threshold in Ruby 2.7+.
-      # That it is slow though. So autocorrection will apply generic `max` or `min`:
+      # It is slow though. So autocorrection will apply generic `max` or `min`:
       #
       # [source,ruby]
       # ----
@@ -39,16 +39,27 @@ module RuboCop
         include RangeHelp
 
         MSG = 'Use `%<prefer>s` instead.'
-        GRATER_OPERATORS = %i[> >=].freeze
+        GREATER_OPERATORS = %i[> >=].freeze
         LESS_OPERATORS = %i[< <=].freeze
-        COMPARISON_OPERATORS = GRATER_OPERATORS + LESS_OPERATORS
+        COMPARISON_OPERATORS = (GREATER_OPERATORS + LESS_OPERATORS).to_set.freeze
+
+        # @!method comparison_condition(node, name)
+        def_node_matcher :comparison_condition, <<~PATTERN
+          {
+            (send $_lhs $COMPARISON_OPERATORS $_rhs)
+            (begin (send $_lhs $COMPARISON_OPERATORS $_rhs))
+          }
+        PATTERN
 
         def on_if(node)
-          lhs, operator, rhs = *node.condition
-          return unless COMPARISON_OPERATORS.include?(operator)
+          lhs, operator, rhs = comparison_condition(node.condition)
+          return unless operator
 
+          # For `unless`, the branches run opposite to an `if`, so swap them to
+          # keep the `max`/`min` decision correct.
           if_branch = node.if_branch
           else_branch = node.else_branch
+          if_branch, else_branch = else_branch, if_branch if node.unless?
           preferred_method = preferred_method(operator, lhs, rhs, if_branch, else_branch)
           return unless preferred_method
 
@@ -63,7 +74,7 @@ module RuboCop
 
         def preferred_method(operator, lhs, rhs, if_branch, else_branch)
           if lhs == if_branch && rhs == else_branch
-            GRATER_OPERATORS.include?(operator) ? 'max' : 'min'
+            GREATER_OPERATORS.include?(operator) ? 'max' : 'min'
           elsif lhs == else_branch && rhs == if_branch
             LESS_OPERATORS.include?(operator) ? 'max' : 'min'
           end

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

@@ -125,13 +125,19 @@ module RuboCop
         private
 
         def check(node)
-          return if node.else?
+          return if node.else? || guard_clause_cop_conflict?(node)
 
           add_offense(node, message: format(message_template, type: node.type)) do |corrector|
             autocorrect(corrector, node)
           end
         end
 
+        def guard_clause_cop_conflict?(node)
+          return false unless node.if_type? && @config.cop_enabled?('Style/GuardClause')
+
+          [node.if_branch, node.else_branch].compact.any?(&:guard_clause?)
+        end
+
         def message_template
           case empty_else_style
           when :empty

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

@@ -28,6 +28,11 @@ module RuboCop
       # delegator.upcase # => FOO
       # ----
       #
+      # When `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is
+      # installed, `respond_to_missing?` defined in another definition of the
+      # same class or module (e.g. a reopening in another file) also
+      # satisfies the check.
+      #
       # @example
       #   # bad
       #   def method_missing(name, *args)
@@ -52,11 +57,14 @@ module RuboCop
       #   end
       #
       class MissingRespondToMissing < Base
+        include ProjectIndexHelp
+
         MSG = 'When using `method_missing`, define `respond_to_missing?`.'
 
         def on_def(node)
           return unless node.method?(:method_missing)
           return if implements_respond_to_missing?(node)
+          return if respond_to_missing_elsewhere?(node)
 
           add_offense(node)
         end
@@ -64,17 +72,42 @@ module RuboCop
 
         private
 
-        def implements_respond_to_missing?(node)
-          return false unless (grand_parent = node.parent.parent)
+        # When `AllCops/UseProjectIndex` is enabled, `respond_to_missing?`
+        # defined in another definition of the same class or module (e.g. a
+        # reopening in another file) also satisfies the check. Ancestors are
+        # not consulted: overriding `method_missing` warrants a matching
+        # `respond_to_missing?` for the same class.
+        def respond_to_missing_elsewhere?(node)
+          return false unless project_index
+          return false unless (namespace_node = node.each_ancestor(:class, :module).first)
+
+          declaration = resolve_constant_in_index(namespace_node.identifier)
+          return false unless declaration.is_a?(Rubydex::Namespace)
+
+          scope = singleton_definition?(node) ? indexed_singleton_of(declaration) : declaration
+          !scope&.member('respond_to_missing?()').nil?
+        rescue StandardError
+          false
+        end
+
+        def singleton_definition?(node)
+          node.defs_type? || node.each_ancestor(:sclass, :class, :module).first&.sclass_type?
+        end
 
-          grand_parent.each_descendant(node.type) do |descendant|
-            return true if descendant.method?(:respond_to_missing?)
+        def implements_respond_to_missing?(node)
+          scope = enclosing_scope(node)
+          search_root = scope || node.parent
+          return false unless search_root
 
-            child = descendant.children.first
-            return true if child.respond_to?(:method?) && child.method?(:respond_to_missing?)
+          search_root.each_descendant(node.type).any? do |descendant|
+            descendant.method?(:respond_to_missing?) && enclosing_scope(descendant).equal?(scope)
           end
+        end
 
-          false
+        # The class/module/`class << self` body that lexically contains `node`,
+        # or `nil` when `node` is defined at the top level.
+        def enclosing_scope(node)
+          node.each_ancestor(:class, :module, :sclass).first
         end
       end
     end

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

@@ -117,17 +117,26 @@ module RuboCop
 
         def separate_mixins(node)
           arguments = node.arguments.reverse
-          mixins = ["#{node.method_name} #{arguments.first.source}"]
+          mixins = [mixin_call(node.method_name, arguments.first.source, node.parenthesized?)]
 
           arguments[1..].inject(mixins) do |replacement, arg|
-            replacement << "#{indent(node)}#{node.method_name} #{arg.source}"
+            call = mixin_call(node.method_name, arg.source, node.parenthesized?)
+            replacement << "#{indent(node)}#{call}"
           end.join("\n")
         end
 
         def group_mixins(node, mixins)
           mixin_names = mixins.reverse.flat_map { |mixin| mixin.arguments.map(&:source) }
 
-          "#{node.method_name} #{mixin_names.join(', ')}"
+          mixin_call(node.method_name, mixin_names.join(', '), mixins.any?(&:parenthesized?))
+        end
+
+        def mixin_call(method_name, arguments_source, parenthesized)
+          if parenthesized
+            "#{method_name}(#{arguments_source})"
+          else
+            "#{method_name} #{arguments_source}"
+          end
         end
       end
     end

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

@@ -47,7 +47,7 @@ module RuboCop
         # @!method include_statement(node)
         def_node_matcher :include_statement, <<~PATTERN
           (send nil? ${:include :extend :prepend}
-            const)
+            const+)
         PATTERN
 
         # @!method in_top_level_scope?(node)

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

@@ -110,9 +110,11 @@ module RuboCop
         def_node_matcher :private_directive?, '(send nil? :private ...)'
 
         def on_module(node)
-          return unless node.body&.begin_type?
+          return unless node.body
 
-          each_wrong_style(node.body.children) do |child_node|
+          body_nodes = node.body.begin_type? ? node.body.children : [node.body]
+
+          each_wrong_style(body_nodes) do |child_node|
             add_offense(child_node) do |corrector|
               next if style == :forbidden
 

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_block_chain.rb

@@ -28,7 +28,7 @@ module RuboCop
         MSG = 'Avoid multi-line chains of blocks.'
 
         def on_block(node)
-          node.send_node.each_node(:send, :csend) do |send_node|
+          node.send_node.each_node(:call) do |send_node|
             receiver = send_node.receiver
 
             next unless receiver&.any_block_type? && receiver.multiline?
@@ -44,6 +44,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
       end
     end
   end