rubocop 1.30.1 → 1.64.0

data/lib/rubocop/cop/internal_affairs/node_matcher_directive.rb

@@ -26,10 +26,18 @@ module RuboCop
         MSG = 'Precede `%<method>s` with a `@!method` YARD directive.'
         MSG_WRONG_NAME = '`@!method` YARD directive has invalid method name, ' \
                          'use `%<expected>s` instead of `%<actual>s`.'
+        MSG_MISSING_SCOPE_SELF = 'Follow the `@!method` YARD directive with ' \
+                                 '`@!scope class` if it is a class method.'
+        MSG_WRONG_SCOPE_SELF = 'Do not use the `@!scope class` YARD directive if it ' \
+                               'is not a class method.'
         MSG_TOO_MANY = 'Multiple `@!method` YARD directives found for this matcher.'
 
         RESTRICT_ON_SEND = %i[def_node_matcher def_node_search].to_set.freeze
-        REGEXP = /^\s*#\s*@!method\s+(?<method_name>[a-z0-9_]+[?!]?)(?:\((?<args>.*)\))?/.freeze
+        REGEXP_METHOD = /
+          ^\s*\#\s*
+          @!method\s+(?<receiver>self\.)?(?<method_name>[a-z0-9_]+[?!]?)(?:\((?<args>.*)\))?
+        /x.freeze
+        REGEXP_SCOPE = /^\s*\#\s*@!scope class/.freeze
 
         # @!method pattern_matcher?(node)
         def_node_matcher :pattern_matcher?, <<~PATTERN
@@ -40,70 +48,135 @@ module RuboCop
           return if node.arguments.none?
           return unless valid_method_name?(node)
 
-          actual_name = node.arguments.first.value
+          actual_name = node.first_argument.value.to_s
+
+          # Ignore cases where the method has a receiver that isn't self
+          return if actual_name.include?('.') && !actual_name.start_with?('self.')
+
           directives = method_directives(node)
           return too_many_directives(node) if directives.size > 1
 
-          directive = directives.first
-          return if directive_correct?(directive, actual_name)
-
-          register_offense(node, directive, actual_name)
+          process_directive(node, actual_name, directives.first)
         end
 
         private
 
         def valid_method_name?(node)
-          node.arguments.first.str_type? || node.arguments.first.sym_type?
+          node.first_argument.str_type? || node.first_argument.sym_type?
         end
 
         def method_directives(node)
           comments = processed_source.ast_with_comments[node]
-
-          comments.map do |comment|
-            match = comment.text.match(REGEXP)
+          group_comments(comments).filter_map do |comment_method, comment_scope|
+            match = comment_method.text.match(REGEXP_METHOD)
             next unless match
 
-            { node: comment, method_name: match[:method_name], args: match[:args] }
-          end.compact
+            {
+              node_method: comment_method,
+              node_scope: comment_scope,
+              method_name: match[:method_name],
+              args: match[:args],
+              receiver: match[:receiver],
+              has_scope_directive: comment_scope&.text&.match?(REGEXP_SCOPE)
+            }
+          end
+        end
+
+        def group_comments(comments)
+          result = []
+          comments.each.with_index do |comment, index|
+            # Grab the scope directive if it is preceded by a method directive
+            if comment.text.include?('@!method')
+              result << if (next_comment = comments[index + 1])&.text&.include?('@!scope')
+                          [comment, next_comment]
+                        else
+                          [comment, nil]
+                        end
+            end
+          end
+          result
         end
 
         def too_many_directives(node)
           add_offense(node, message: MSG_TOO_MANY)
         end
 
-        def directive_correct?(directive, actual_name)
-          directive && directive[:method_name] == actual_name.to_s
+        def process_directive(node, actual_name, directive)
+          return unless (offense_type = directive_offense_type(directive, actual_name))
+
+          register_offense(offense_type, node, directive, actual_name)
+        end
+
+        def directive_offense_type(directive, actual_name)
+          return :missing_directive unless directive
+
+          return :wrong_scope if wrong_scope(directive, actual_name)
+          return :no_scope if no_scope(directive, actual_name)
+
+          # The method directive being prefixed by 'self.' is always an offense.
+          # The matched method_name does not contain the receiver but the
+          # def_node_match method name may so it must be removed.
+          if directive[:method_name] != remove_receiver(actual_name) || directive[:receiver]
+            :wrong_name
+          end
+        end
+
+        def wrong_scope(directive, actual_name)
+          !actual_name.start_with?('self.') && directive[:has_scope_directive]
+        end
+
+        def no_scope(directive, actual_name)
+          actual_name.start_with?('self.') && !directive[:has_scope_directive]
         end
 
-        def register_offense(node, directive, actual_name)
-          message = formatted_message(directive, actual_name, node.method_name)
+        def register_offense(offense_type, node, directive, actual_name)
+          message = formatted_message(offense_type, directive, actual_name, node.method_name)
 
           add_offense(node, message: message) do |corrector|
-            if directive
-              correct_directive(corrector, directive, actual_name)
-            else
-              insert_directive(corrector, node, actual_name)
+            case offense_type
+            when :wrong_name
+              correct_method_directive(corrector, directive, actual_name)
+            when :wrong_scope
+              remove_scope_directive(corrector, directive)
+            when :no_scope
+              insert_scope_directive(corrector, directive[:node_method])
+            when :missing_directive
+              insert_method_directive(corrector, node, actual_name)
             end
           end
         end
 
-        def formatted_message(directive, actual_name, method_name)
-          if directive
-            format(MSG_WRONG_NAME, expected: actual_name, actual: directive[:method_name])
-          else
+        # rubocop:disable Metrics/MethodLength
+        def formatted_message(offense_type, directive, actual_name, method_name)
+          case offense_type
+          when :wrong_name
+            # Add the receiver to the name when showing an offense
+            current_name = if directive[:receiver]
+                             directive[:receiver] + directive[:method_name]
+                           else
+                             directive[:method_name]
+                           end
+            # The correct name will never include a receiver, remove it
+            format(MSG_WRONG_NAME, expected: remove_receiver(actual_name), actual: current_name)
+          when :wrong_scope
+            MSG_WRONG_SCOPE_SELF
+          when :no_scope
+            MSG_MISSING_SCOPE_SELF
+          when :missing_directive
             format(MSG, method: method_name)
           end
         end
+        # rubocop:enable Metrics/MethodLength
+
+        def remove_receiver(current)
+          current.delete_prefix('self.')
+        end
 
-        def insert_directive(corrector, node, actual_name)
+        def insert_method_directive(corrector, node, actual_name)
           # If the pattern matcher uses arguments (`%1`, `%2`, etc.), include them in the directive
           arguments = pattern_arguments(node.arguments[1].source)
 
-          range = range_with_surrounding_space(
-            range: node.loc.expression,
-            side: :left,
-            newlines: false
-          )
+          range = range_with_surrounding_space(node.source_range, side: :left, newlines: false)
           indentation = range.source.match(/^\s*/)[0]
           directive = "#{indentation}# @!method #{actual_name}(#{arguments.join(', ')})\n"
           directive = "\n#{directive}" if add_newline?(node)
@@ -111,6 +184,14 @@ module RuboCop
           corrector.insert_before(range, directive)
         end
 
+        def insert_scope_directive(corrector, node)
+          range = range_with_surrounding_space(node.source_range, side: :left, newlines: false)
+          indentation = range.source.match(/^\s*/)[0]
+          directive = "\n#{indentation}# @!scope class"
+
+          corrector.insert_after(node, directive)
+        end
+
         def pattern_arguments(pattern)
           arguments = %w[node]
           max_pattern_var = pattern.scan(/(?<=%)\d+/).map(&:to_i).max
@@ -121,11 +202,11 @@ module RuboCop
         def add_newline?(node)
           # Determine if a blank line should be inserted before the new directive
           # in order to spread out pattern matchers
-          return if node.sibling_index&.zero?
-          return unless node.parent
+          return false if node.sibling_index&.zero?
+          return false unless node.parent
 
           prev_sibling = node.parent.child_nodes[node.sibling_index - 1]
-          return unless prev_sibling && pattern_matcher?(prev_sibling)
+          return false unless prev_sibling && pattern_matcher?(prev_sibling)
 
           node.loc.line == last_line(prev_sibling) + 1
         end
@@ -138,12 +219,21 @@ module RuboCop
           end
         end
 
-        def correct_directive(corrector, directive, actual_name)
-          correct = "@!method #{actual_name}"
-          regexp = /@!method\s+#{Regexp.escape(directive[:method_name])}/
+        def correct_method_directive(corrector, directive, actual_name)
+          correct = "@!method #{remove_receiver(actual_name)}"
+          current_name = (directive[:receiver] || '') + directive[:method_name]
+          regexp = /@!method\s+#{Regexp.escape(current_name)}/
 
-          replacement = directive[:node].text.gsub(regexp, correct)
-          corrector.replace(directive[:node], replacement)
+          replacement = directive[:node_method].text.gsub(regexp, correct)
+          corrector.replace(directive[:node_method], replacement)
+        end
+
+        def remove_scope_directive(corrector, directive)
+          range = range_by_whole_lines(
+            directive[:node_scope].source_range,
+            include_final_newline: true
+          )
+          corrector.remove(range)
         end
       end
     end

data/lib/rubocop/cop/internal_affairs/node_type_predicate.rb

@@ -30,7 +30,7 @@ module RuboCop
 
             message = format(MSG, type: node_type)
             add_offense(node, message: message) do |corrector|
-              range = node.loc.expression.with(begin_pos: receiver.loc.expression.end_pos + 1)
+              range = node.source_range.with(begin_pos: receiver.source_range.end_pos + 1)
               corrector.replace(range, "#{node_type}_type?")
             end
           end

data/lib/rubocop/cop/internal_affairs/numblock_handler.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks for missing `numblock handlers. The blocks with numbered
+      # arguments introduced in Ruby 2.7 are parsed with a node type of
+      # `numblock` instead of block. Cops that define `block` handlers
+      # need to define `numblock` handlers or disable this cope for them.
+      #
+      # @example
+      #
+      #   # bad
+      #   class BlockRelatedCop < Base
+      #     def on_block(node)
+      #     end
+      #   end
+      #
+      #   # good
+      #   class BlockRelatedCop < Base
+      #     def on_block(node)
+      #     end
+      #
+      #     alias on_numblock on_block
+      #   end
+      #
+      #   class BlockRelatedCop < Base
+      #     def on_block(node)
+      #     end
+      #
+      #     alias_method :on_numblock, :on_block
+      #   end
+      #
+      #   class BlockRelatedCop < Base
+      #     def on_block(node)
+      #     end
+      #
+      #     def on_numblock(node)
+      #     end
+      #   end
+      class NumblockHandler < Base
+        MSG = 'Define on_numblock to handle blocks with numbered arguments.'
+
+        def on_def(node)
+          return unless block_handler?(node)
+          return unless node.parent
+
+          add_offense(node) unless numblock_handler?(node.parent)
+        end
+
+        private
+
+        # @!method block_handler?(node)
+        def_node_matcher :block_handler?, <<~PATTERN
+          (def :on_block (args (arg :node)) ...)
+        PATTERN
+
+        # @!method numblock_handler?(node)
+        def_node_matcher :numblock_handler?, <<~PATTERN
+          {
+            `(def :on_numblock (args (arg :node)) ...)
+            `(alias (sym :on_numblock) (sym :on_block))
+            `(send nil? :alias_method (sym :on_numblock) (sym :on_block))
+          }
+        PATTERN
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs/processed_source_buffer_name.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Enforces the use of `processed_source.file_path` instead of `processed_source.buffer.name`.
+      #
+      # @example
+      #
+      #   # bad
+      #   processed_source.buffer.name
+      #
+      #   # good
+      #   processed_source.file_path
+      #
+      class ProcessedSourceBufferName < Base
+        extend AutoCorrector
+
+        MSG = 'Use `file_path` instead.'
+
+        RESTRICT_ON_SEND = %i[name].freeze
+
+        # @!method processed_source_buffer_name?(node)
+        def_node_matcher :processed_source_buffer_name?, <<~PATTERN
+          (send
+            (send
+              {(lvar :processed_source) (send nil? :processed_source)} :buffer) :name)
+        PATTERN
+
+        def on_send(node)
+          return unless processed_source_buffer_name?(node)
+
+          offense_range = node.children.first.loc.selector.begin.join(node.source_range.end)
+
+          add_offense(offense_range) do |corrector|
+            corrector.replace(offense_range, 'file_path')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs/redundant_expect_offense_arguments.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks for redundant arguments of `RuboCop::RSpec::ExpectOffense`'s methods.
+      #
+      # @example
+      #
+      #   # bad
+      #   expect_no_offenses('code', keyword: keyword)
+      #
+      #   # good
+      #   expect_no_offenses('code')
+      #
+      class RedundantExpectOffenseArguments < Base
+        extend AutoCorrector
+
+        MSG = 'Remove the redundant arguments.'
+        RESTRICT_ON_SEND = %i[expect_no_offenses].freeze
+
+        def on_send(node)
+          return if node.arguments.one? || !node.arguments[1]&.hash_type?
+
+          range = node.first_argument.source_range.end.join(node.last_argument.source_range.end)
+
+          add_offense(range) do |corrector|
+            corrector.remove(range)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs/redundant_let_rubocop_config_new.rb

@@ -31,9 +31,17 @@ module RuboCop
             (send nil? :let
               (sym :config))
             (args)
-            (send
-              (const
-                (const nil? :RuboCop) :Config) :new))
+            {
+              (send
+                (const
+                  (const nil? :RuboCop) :Config) :new)
+              (send
+                (const
+                  (const nil? :RuboCop) :Config) :new
+                    (hash (pair (send (send (send nil? :described_class) :badge) :to_s)
+                      (send nil? :cop_config))))
+            }
+          )
         PATTERN
 
         def on_block(node)

data/lib/rubocop/cop/internal_affairs/redundant_location_argument.rb

@@ -43,7 +43,7 @@ module RuboCop
         private
 
         def offending_range(node)
-          with_space = range_with_surrounding_space(range: node.loc.expression)
+          with_space = range_with_surrounding_space(node.source_range)
 
           range_with_surrounding_comma(with_space, :left)
         end

data/lib/rubocop/cop/internal_affairs/redundant_message_argument.rb

@@ -56,7 +56,7 @@ module RuboCop
         private
 
         def offending_range(node)
-          with_space = range_with_surrounding_space(range: node.loc.expression)
+          with_space = range_with_surrounding_space(node.source_range)
 
           range_with_surrounding_comma(with_space, :left)
         end

data/lib/rubocop/cop/internal_affairs/redundant_method_dispatch_node.rb

@@ -14,6 +14,12 @@ module RuboCop
       #   node.method_name
       #
       #   # bad
+      #   node.send_node.method?(:method_name)
+      #
+      #   # good
+      #   node.method?(:method_name)
+      #
+      #   # bad
       #   node.send_node.receiver
       #
       #   # good
@@ -24,11 +30,14 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Remove the redundant `send_node`.'
-        RESTRICT_ON_SEND = %i[method_name receiver].freeze
+        RESTRICT_ON_SEND = %i[method_name method? receiver].freeze
 
         # @!method dispatch_method(node)
         def_node_matcher :dispatch_method, <<~PATTERN
-          (send $(send _ :send_node) _)
+          {
+            (send $(send _ :send_node) {:method_name :receiver})
+            (send $(send _ :send_node) :method? _)
+          }
         PATTERN
 
         def on_send(node)

data/lib/rubocop/cop/internal_affairs/redundant_source_range.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks for redundant `source_range`.
+      #
+      # @example
+      #
+      #   # bad
+      #   node.source_range.source
+      #
+      #   # good
+      #   node.source
+      #
+      #   # bad
+      #   add_offense(node) { |corrector| corrector.replace(node.source_range, prefer) }
+      #   add_offense(node) { |corrector| corrector.insert_before(node.source_range, prefer) }
+      #   add_offense(node) { |corrector| corrector.insert_before_multi(node.source_range, prefer) }
+      #   add_offense(node) { |corrector| corrector.insert_after(node.source_range, prefer) }
+      #   add_offense(node) { |corrector| corrector.insert_after_multi(node.source_range, prefer) }
+      #   add_offense(node) { |corrector| corrector.swap(node.source_range, before, after) }
+      #
+      #   # good
+      #   add_offense(node) { |corrector| corrector.replace(node, prefer) }
+      #   add_offense(node) { |corrector| corrector.insert_before(node, prefer) }
+      #   add_offense(node) { |corrector| corrector.insert_before_multi(node, prefer) }
+      #   add_offense(node) { |corrector| corrector.insert_after(node, prefer) }
+      #   add_offense(node) { |corrector| corrector.insert_after_multi(node, prefer) }
+      #   add_offense(node) { |corrector| corrector.swap(node, before, after) }
+      #
+      class RedundantSourceRange < Base
+        extend AutoCorrector
+
+        MSG = 'Remove the redundant `source_range`.'
+        RESTRICT_ON_SEND = %i[
+          source
+          replace remove insert_before insert_before_multi insert_after insert_after_multi swap
+        ].freeze
+
+        # @!method redundant_source_range(node)
+        def_node_matcher :redundant_source_range, <<~PATTERN
+          {
+            (send $(send _ :source_range) :source)
+            (send _ {
+              :replace :insert_before :insert_before_multi :insert_after :insert_after_multi
+            } $(send _ :source_range) _)
+            (send _ :remove $(send _ :source_range))
+            (send _ :swap $(send _ :source_range) _ _)
+          }
+        PATTERN
+
+        def on_send(node)
+          return unless (source_range = redundant_source_range(node))
+          return if source_range.receiver.send_type? && source_range.receiver.method?(:buffer)
+
+          selector = source_range.loc.selector
+
+          add_offense(selector) do |corrector|
+            corrector.remove(source_range.loc.dot.join(selector))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs/single_line_comparison.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Enforces the use of `node.single_line?` instead of
+      # comparing `first_line` and `last_line` for equality.
+      #
+      # @example
+      #   # bad
+      #   node.loc.first_line == node.loc.last_line
+      #
+      #   # bad
+      #   node.loc.last_line == node.loc.first_line
+      #
+      #   # bad
+      #   node.loc.line == node.loc.last_line
+      #
+      #   # bad
+      #   node.loc.last_line == node.loc.line
+      #
+      #   # bad
+      #   node.first_line == node.last_line
+      #
+      #   # good
+      #   node.single_line?
+      #
+      class SingleLineComparison < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<preferred>s`.'
+        RESTRICT_ON_SEND = %i[== !=].freeze
+
+        # @!method single_line_comparison(node)
+        def_node_matcher :single_line_comparison, <<~PATTERN
+          {
+            (send (send $_receiver {:line :first_line}) {:== :!=} (send _receiver :last_line))
+            (send (send $_receiver :last_line) {:== :!=} (send _receiver {:line :first_line}))
+          }
+        PATTERN
+
+        def on_send(node)
+          return unless (receiver = single_line_comparison(node))
+
+          bang = node.method?(:!=) ? '!' : ''
+          preferred = "#{bang}#{extract_receiver(receiver)}.single_line?"
+
+          add_offense(node, message: format(MSG, preferred: preferred)) do |corrector|
+            corrector.replace(node, preferred)
+          end
+        end
+
+        private
+
+        def extract_receiver(node)
+          node = node.receiver if node.send_type? && %i[loc source_range].include?(node.method_name)
+          node.source
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs/useless_message_assertion.rb

@@ -27,6 +27,8 @@ module RuboCop
         PATTERN
 
         def on_new_investigation
+          return if processed_source.blank?
+
           assertions_using_described_class_msg.each { |node| add_offense(node) }
         end
 

data/lib/rubocop/cop/internal_affairs/useless_restrict_on_send.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Check for useless `RESTRICT_ON_SEND`.
+      #
+      # @example
+      #   # bad
+      #   class FooCop
+      #     RESTRICT_ON_SEND = %i[bad_method].freeze
+      #   end
+      #
+      #   # good
+      #   class FooCop
+      #     RESTRICT_ON_SEND = %i[bad_method].freeze
+      #     def on_send(node)
+      #       # ...
+      #     end
+      #   end
+      #
+      #   # good
+      #   class FooCop
+      #     RESTRICT_ON_SEND = %i[bad_method].freeze
+      #     def after_send(node)
+      #       # ...
+      #     end
+      #   end
+      #
+      class UselessRestrictOnSend < Base
+        extend AutoCorrector
+
+        MSG = 'Useless `RESTRICT_ON_SEND` is defined.'
+
+        # @!method defined_send_callback?(node)
+        def_node_search :defined_send_callback?, <<~PATTERN
+          {
+            (def {:on_send :after_send} ...)
+            (alias (sym {:on_send :after_send}) _source ...)
+            (send nil? :alias_method {(sym {:on_send :after_send}) (str {"on_send" "after_send"})} _source ...)
+          }
+        PATTERN
+
+        def on_casgn(node)
+          return if !restrict_on_send?(node) || defined_send_callback?(node.parent)
+
+          add_offense(node) do |corrector|
+            corrector.remove(node)
+          end
+        end
+
+        private
+
+        def restrict_on_send?(node)
+          node.name == :RESTRICT_ON_SEND
+        end
+      end
+    end
+  end
+end