rubocop 1.53.0 → 1.90.0

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

@@ -6,27 +6,65 @@ module RuboCop
       # Checks for the presence of `method_missing` without also
       # defining `respond_to_missing?`.
       #
+      # Not defining `respond_to_missing?` will cause metaprogramming
+      # methods like `respond_to?` to behave unexpectedly:
+      #
+      # [source,ruby]
+      # ----
+      # class StringDelegator
+      #   def initialize(string)
+      #     @string = string
+      #   end
+      #
+      #   def method_missing(name, *args)
+      #     @string.send(name, *args)
+      #   end
+      # end
+      #
+      # delegator = StringDelegator.new("foo")
+      # # Claims to not respond to `upcase`.
+      # delegator.respond_to?(:upcase) # => false
+      # # But you can call it.
+      # 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
+      #   # bad
       #   def method_missing(name, *args)
-      #     # ...
+      #     if @delegate.respond_to?(name)
+      #       @delegate.send(name, *args)
+      #     else
+      #       super
+      #     end
       #   end
       #
-      #   #good
+      #   # good
       #   def respond_to_missing?(name, include_private)
-      #     # ...
+      #     @delegate.respond_to?(name) || super
       #   end
       #
       #   def method_missing(name, *args)
-      #     # ...
+      #     if @delegate.respond_to?(name)
+      #       @delegate.send(name, *args)
+      #     else
+      #       super
+      #     end
       #   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
@@ -34,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)
 
-          grand_parent.each_descendant(node.type) do |descendant|
-            return true if descendant.method?(:respond_to_missing?)
+          declaration = resolve_constant_in_index(namespace_node.identifier)
+          return false unless declaration.is_a?(Rubydex::Namespace)
 
-            child = descendant.children.first
-            return true if child.respond_to?(:method?) && child.method?(:respond_to_missing?)
+          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
+
+        def implements_respond_to_missing?(node)
+          scope = enclosing_scope(node)
+          search_root = scope || node.parent
+          return false unless search_root
+
+          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

@@ -40,7 +40,7 @@ module RuboCop
         def on_class(node)
           begin_node = node.child_nodes.find(&:begin_type?) || node
           begin_node.each_child_node(:send).select(&:macro?).each do |macro|
-            next unless MIXIN_METHODS.include?(macro.method_name)
+            next if !MIXIN_METHODS.include?(macro.method_name) || macro.arguments.empty?
 
             check(macro)
           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,10 +28,10 @@ module RuboCop
         MSG = 'Avoid multi-line chains of blocks.'
 
         def on_block(node)
-          node.send_node.each_node(:send) do |send_node|
+          node.send_node.each_node(:call) do |send_node|
             receiver = send_node.receiver
 
-            next unless (receiver&.block_type? || receiver&.numblock_type?) && receiver&.multiline?
+            next unless receiver&.any_block_type? && receiver.multiline?
 
             range = range_between(receiver.loc.end.begin_pos, node.send_node.source_range.end_pos)
 
@@ -44,6 +44,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
       end
     end
   end

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

@@ -23,11 +23,13 @@ module RuboCop
               'clause in a multiline statement.'
 
         def on_if(node)
+          return if part_of_ignored_node?(node)
           return unless node.modifier_form? && node.body.multiline?
 
           add_offense(node, message: format(MSG, keyword: node.keyword)) do |corrector|
             corrector.replace(node, to_normal_if(node))
           end
+          ignore_node(node)
         end
 
         private

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,13 @@ module RuboCop
         private
 
         def non_modifier_then?(node)
-          NON_MODIFIER_THEN.match?(node.loc.begin&.source_line)
+          node.multiline? && own_then?(node) && node.loc.begin.line != node.if_branch&.loc&.line
+        end
+
+        # Prism gives an `elsif` with no `then` of its own the previous branch's `then` location,
+        # which lies outside the node.
+        def own_then?(node)
+          node.then? && node.source_range.contains?(node.loc.begin)
         end
       end
     end

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

@@ -39,11 +39,11 @@ module RuboCop
         BRACES_MSG = 'Wrap multiline memoization blocks in `(` and `)`.'
 
         def on_or_asgn(node)
-          _lhs, rhs = *node
+          rhs = node.expression
 
           return unless bad_rhs?(rhs)
 
-          add_offense(node.source_range) do |corrector|
+          add_offense(node) do |corrector|
             if style == :keyword
               keyword_autocorrect(rhs, corrector)
             else
@@ -65,10 +65,16 @@ module RuboCop
           if style == :keyword
             rhs.begin_type?
           else
-            rhs.kwbegin_type?
+            # A `begin` block with `rescue`/`ensure` cannot be expressed with
+            # parentheses, so wrapping it in `(` and `)` is not possible.
+            rhs.kwbegin_type? && !contains_rescue_or_ensure?(rhs)
           end
         end
 
+        def contains_rescue_or_ensure?(node)
+          node.each_child_node(:rescue, :ensure).any?
+        end
+
         def keyword_autocorrect(node, corrector)
           node_buf = node.source_range.source_buffer
           corrector.replace(node.loc.begin, keyword_begin_str(node, node_buf))

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

@@ -38,6 +38,7 @@ module RuboCop
 
         private
 
+        # rubocop:disable-next Metrics/AbcSize
         def autocorrect(corrector, node, begin_of_arguments)
           arguments = node.arguments
           joined_arguments = arguments.map(&:source).join(', ')
@@ -49,7 +50,16 @@ module RuboCop
             corrector.remove(range_by_whole_lines(arguments.loc.end, include_final_newline: true))
           end
 
-          corrector.remove(arguments_range(node))
+          arguments_range = range_with_surrounding_space(arguments_range(node), side: :left)
+          # If the method name isn't on the same line as `def`, pull the name and
+          # the opening parenthesis up next to `def` so the collapsed signature
+          # stays on a single line and remains valid Ruby.
+          if arguments_range.first_line != opening_line(node)
+            prefix_range = range_between(node.loc.keyword.end_pos, begin_of_arguments.begin_pos)
+            corrector.replace(prefix_range, " #{prefix_range.source.strip}")
+          end
+
+          corrector.remove(arguments_range)
           corrector.insert_after(begin_of_arguments, joined_arguments)
         end
 
@@ -57,14 +67,6 @@ module RuboCop
           processed_source[arguments.last_line - 1].strip
         end
 
-        def arguments_range(node)
-          range = range_between(
-            node.first_argument.source_range.begin_pos, node.last_argument.source_range.end_pos
-          )
-
-          range_with_surrounding_space(range, side: :left)
-        end
-
         def opening_line(node)
           node.first_line
         end
@@ -74,6 +76,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
 
@@ -82,11 +86,12 @@ module RuboCop
         end
 
         def definition_width(node)
-          node.source_range.begin.join(node.arguments.source_range.end).length
-        end
+          # Measure the collapsed single-line width the autocorrect would
+          # produce, not the multi-line source length, so a signature that
+          # would fit on one line is not skipped.
+          signature = node.source_range.begin.join(node.arguments.source_range.end).source
 
-        def max_line_length
-          config.for_cop('Layout/LineLength')['Max'] || 120
+          signature.gsub(/\s+/, ' ').length
         end
       end
     end

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

@@ -39,7 +39,7 @@ module RuboCop
 
         MSG_IF = 'Avoid multi-line ternary operators, use `if` or `unless` instead.'
         MSG_SINGLE_LINE = 'Avoid multi-line ternary operators, use single-line instead.'
-        SINGLE_LINE_TYPES = %i[return break next send].freeze
+        SINGLE_LINE_TYPES = %i[return break next send csend].freeze
 
         def on_if(node)
           return unless offense?(node)
@@ -47,19 +47,21 @@ module RuboCop
           message = enforce_single_line_ternary_operator?(node) ? MSG_SINGLE_LINE : MSG_IF
 
           add_offense(node, message: message) do |corrector|
+            next if part_of_ignored_node?(node)
+
             autocorrect(corrector, node)
+
+            ignore_node(node)
           end
         end
 
         private
 
         def offense?(node)
-          node.ternary? && node.multiline?
+          node.ternary? && node.multiline? && node.source != replacement(node)
         end
 
         def autocorrect(corrector, node)
-          return unless offense?(node)
-
           corrector.replace(node, replacement(node))
           return unless (parent = node.parent)
           return unless (comments_in_condition = comments_in_condition(node))

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

@@ -54,10 +54,6 @@ module RuboCop
 
           same_line?(when_node, when_node.body)
         end
-
-        def accept_node_type?(node)
-          node&.array_type? || node&.hash_type?
-        end
       end
     end
   end

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

@@ -55,70 +55,77 @@ module RuboCop
         MSG = 'Avoid comparing a variable with multiple items ' \
               'in a conditional, use `Array#include?` instead.'
 
-        def on_new_investigation
-          @last_comparison = nil
-        end
-
-        def on_or(node)
-          reset_comparison if switch_comparison?(node)
-
-          root_of_or_node = root_of_or_node(node)
+        # @!method simple_double_comparison?(node)
+        def_node_matcher :simple_double_comparison?, <<~PATTERN
+          (send lvar :== lvar)
+        PATTERN
 
-          return unless node == root_of_or_node
-          return unless nested_variable_comparison?(root_of_or_node)
-          return if @allowed_method_comparison
-          return if @compared_elements.size < comparisons_threshold
+        # @!method simple_comparison_lhs(node)
+        def_node_matcher :simple_comparison_lhs, <<~PATTERN
+          (send ${lvar call} :== $_)
+        PATTERN
 
-          add_offense(node) do |corrector|
-            elements = @compared_elements.join(', ')
-            prefer_method = "[#{elements}].include?(#{variables_in_node(node).first})"
+        # @!method simple_comparison_rhs(node)
+        def_node_matcher :simple_comparison_rhs, <<~PATTERN
+          (send $_ :== ${lvar call})
+        PATTERN
 
-            corrector.replace(node, prefer_method)
+        def on_or(node)
+          return unless node == root_of_or_node(node)
+          return unless nested_comparison?(node)
+          return unless (variable, values, skipped = find_offending_var(node))
+          return if values.size < comparisons_threshold
+
+          range = offense_range(values)
+          # Bail when an allowed method comparison sits between the collected
+          # values: collapsing them into a single `include?` would drop it.
+          return if skipped_within_range?(skipped, range)
+
+          add_offense(range) do |corrector|
+            corrector.replace(range, preferred_method(variable, values))
           end
-
-          @last_comparison = node
         end
 
         private
 
-        # @!method simple_double_comparison?(node)
-        def_node_matcher :simple_double_comparison?, '(send $lvar :== $lvar)'
-
-        # @!method simple_comparison_lhs?(node)
-        def_node_matcher :simple_comparison_lhs?, <<~PATTERN
-          (send $lvar :== $_)
-        PATTERN
-
-        # @!method simple_comparison_rhs?(node)
-        def_node_matcher :simple_comparison_rhs?, <<~PATTERN
-          (send $_ :== $lvar)
-        PATTERN
-
-        def nested_variable_comparison?(node)
-          return false unless nested_comparison?(node)
+        def skipped_within_range?(skipped, range)
+          skipped.any? { |node_part| range.contains?(node_part.source_range) }
+        end
 
-          variables_in_node(node).count == 1
+        def preferred_method(variable, values)
+          elements = values.map(&:source).join(', ')
+          argument = variable.lvar_type? ? variable_name(variable) : variable.source
+          "[#{elements}].include?(#{argument})"
         end
 
-        def variables_in_node(node)
+        def find_offending_var(node, variables = Set.new, values = [], skipped = [])
           if node.or_type?
-            node.node_parts.flat_map { |node_part| variables_in_node(node_part) }.uniq
-          else
-            variables_in_simple_node(node)
+            find_offending_var(node.lhs, variables, values, skipped)
+            find_offending_var(node.rhs, variables, values, skipped)
+          elsif simple_double_comparison?(node)
+            return
+          elsif (comparison = simple_comparison(node))
+            collect_comparison(node, comparison, variables, values, skipped)
           end
+
+          [variables.first, values, skipped] if variables.any?
         end
 
-        def variables_in_simple_node(node)
-          simple_double_comparison?(node) do |var1, var2|
-            return [variable_name(var1), variable_name(var2)]
-          end
-          if (var, obj = simple_comparison_lhs?(node)) || (obj, var = simple_comparison_rhs?(node))
-            @allowed_method_comparison = true if allow_method_comparison? && obj.send_type?
-            @compared_elements << obj.source
-            return [variable_name(var)]
+        def collect_comparison(node, comparison, variables, values, skipped)
+          var, obj = comparison
+          if allow_method_comparison? && obj.call_type?
+            skipped << node
+            return
           end
 
-          []
+          variables << var
+          return if variables.size > 1
+
+          values << obj
+        end
+
+        def offense_range(values)
+          values.first.parent.source_range.begin.join(values.last.parent.source_range.end)
         end
 
         def variable_name(node)
@@ -134,7 +141,15 @@ module RuboCop
         end
 
         def comparison?(node)
-          simple_comparison_lhs?(node) || simple_comparison_rhs?(node) || nested_comparison?(node)
+          !!simple_comparison(node) || nested_comparison?(node)
+        end
+
+        def simple_comparison(node)
+          if (var, obj = simple_comparison_lhs(node)) || (obj, var = simple_comparison_rhs(node))
+            return if var.call_type? && !allow_method_comparison?
+
+            [var, obj]
+          end
         end
 
         def root_of_or_node(or_node)
@@ -147,17 +162,6 @@ module RuboCop
           end
         end
 
-        def switch_comparison?(node)
-          return true if @last_comparison.nil?
-
-          @last_comparison.descendants.none?(node)
-        end
-
-        def reset_comparison
-          @compared_elements = []
-          @allowed_method_comparison = false
-        end
-
         def allow_method_comparison?
           cop_config.fetch('AllowMethodComparison', true)
         end