rubocop 1.50.2 → 1.62.1

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,62 +48,131 @@ 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 register_offense(node, directive, actual_name)
-          message = formatted_message(directive, actual_name, node.method_name)
+        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(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)
 
@@ -107,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
@@ -117,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
@@ -134,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_method].text.gsub(regexp, correct)
+          corrector.replace(directive[:node_method], replacement)
+        end
 
-          replacement = directive[:node].text.gsub(regexp, correct)
-          corrector.replace(directive[:node], replacement)
+        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/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_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/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.rb

@@ -12,6 +12,7 @@ require_relative 'internal_affairs/location_line_equality_comparison'
 require_relative 'internal_affairs/method_name_end_with'
 require_relative 'internal_affairs/method_name_equal'
 require_relative 'internal_affairs/node_destructuring'
+require_relative 'internal_affairs/node_first_or_last_argument'
 require_relative 'internal_affairs/node_matcher_directive'
 require_relative 'internal_affairs/node_type_predicate'
 require_relative 'internal_affairs/numblock_handler'
@@ -19,6 +20,7 @@ require_relative 'internal_affairs/offense_location_keyword'
 require_relative 'internal_affairs/processed_source_buffer_name'
 require_relative 'internal_affairs/redundant_context_config_parameter'
 require_relative 'internal_affairs/redundant_described_class_as_subject'
+require_relative 'internal_affairs/redundant_expect_offense_arguments'
 require_relative 'internal_affairs/redundant_let_rubocop_config_new'
 require_relative 'internal_affairs/redundant_location_argument'
 require_relative 'internal_affairs/redundant_message_argument'

data/lib/rubocop/cop/layout/argument_alignment.rb

@@ -79,7 +79,7 @@ module RuboCop
 
         def arguments_with_last_arg_pairs(node)
           items = node.arguments[0..-2]
-          last_arg = node.arguments.last
+          last_arg = node.last_argument
 
           if last_arg.hash_type? && !last_arg.braces?
             items += last_arg.pairs

data/lib/rubocop/cop/layout/class_structure.rb

@@ -68,6 +68,13 @@ module RuboCop
       #        - extend
       # ----
       #
+      # @safety
+      #   Autocorrection is unsafe because class methods and module inclusion
+      #   can behave differently, based on which methods or constants have
+      #   already been defined.
+      #
+      #   Constants will only be moved when they are assigned with literals.
+      #
       # @example
       #   # bad
       #   # Expect extend be before constant

data/lib/rubocop/cop/layout/closing_heredoc_indentation.rb

@@ -3,7 +3,6 @@
 module RuboCop
   module Cop
     module Layout
-      #
       # Checks the indentation of here document closings.
       #
       # @example
@@ -73,7 +72,7 @@ module RuboCop
         end
 
         def argument_indentation_correct?(node)
-          return unless node.argument? || node.chained?
+          return false unless node.argument? || node.chained?
 
           opening_indentation(
             find_node_used_heredoc_argument(node.parent)

data/lib/rubocop/cop/layout/dot_position.rb

@@ -32,7 +32,7 @@ module RuboCop
         end
 
         def on_send(node)
-          return unless node.dot? || ampersand_dot?(node)
+          return unless node.dot? || node.safe_navigation?
 
           return correct_style_detected if proper_dot_position?(node)
 
@@ -133,10 +133,6 @@ module RuboCop
           # l.(1) has no selector, so we use the opening parenthesis instead
           node.loc.selector || node.loc.begin
         end
-
-        def ampersand_dot?(node)
-          node.loc.respond_to?(:dot) && node.loc.dot && node.loc.dot.is?('&.')
-        end
       end
     end
   end

data/lib/rubocop/cop/layout/empty_line_after_guard_clause.rb

@@ -3,7 +3,23 @@
 module RuboCop
   module Cop
     module Layout
-      # Enforces empty line after guard clause
+      # Enforces empty line after guard clause.
+      #
+      # This cop allows `# :nocov:` directive after guard clause because
+      # SimpleCov excludes code from the coverage report by wrapping it in `# :nocov:`:
+      #
+      # [source,ruby]
+      # ----
+      # def foo
+      #   # :nocov:
+      #   return if condition
+      #   # :nocov:
+      #   bar
+      # end
+      # ----
+      #
+      # Refer to SimpleCov's documentation for more details:
+      # https://github.com/simplecov-ruby/simplecov#ignoringskipping-code
       #
       # @example
       #
@@ -42,19 +58,22 @@ module RuboCop
 
         MSG = 'Add empty line after guard clause.'
         END_OF_HEREDOC_LINE = 1
+        SIMPLE_DIRECTIVE_COMMENT_PATTERN = /\A# *:nocov:\z/.freeze
 
         def on_if(node)
           return if correct_style?(node)
           return if multiple_statements_on_line?(node)
 
           if node.modifier_form? && (heredoc_node = last_heredoc_argument(node))
-            return if next_line_empty_or_enable_directive_comment?(heredoc_line(node, heredoc_node))
+            if next_line_empty_or_allowed_directive_comment?(heredoc_line(node, heredoc_node))
+              return
+            end
 
             add_offense(heredoc_node.loc.heredoc_end) do |corrector|
               autocorrect(corrector, heredoc_node)
             end
           else
-            return if next_line_empty_or_enable_directive_comment?(node.last_line)
+            return if next_line_empty_or_allowed_directive_comment?(node.last_line)
 
             add_offense(offense_location(node)) { |corrector| autocorrect(corrector, node) }
           end
@@ -70,7 +89,7 @@ module RuboCop
                        end
 
           next_line = node_range.last_line + 1
-          if next_line_enable_directive_comment?(next_line)
+          if next_line_allowed_directive_comment?(next_line)
             node_range = processed_source.comment_at_line(next_line)
           end
 
@@ -88,21 +107,21 @@ module RuboCop
           node.if_branch&.guard_clause?
         end
 
-        def next_line_empty_or_enable_directive_comment?(line)
+        def next_line_empty_or_allowed_directive_comment?(line)
           return true if next_line_empty?(line)
 
           next_line = line + 1
-          next_line_enable_directive_comment?(next_line) && next_line_empty?(next_line)
+          next_line_allowed_directive_comment?(next_line) && next_line_empty?(next_line)
         end
 
         def next_line_empty?(line)
           processed_source[line].blank?
         end
 
-        def next_line_enable_directive_comment?(line)
+        def next_line_allowed_directive_comment?(line)
           return false unless (comment = processed_source.comment_at_line(line))
 
-          DirectiveComment.new(comment).enabled?
+          DirectiveComment.new(comment).enabled? || simplecov_directive_comment?(comment)
         end
 
         def next_line_rescue_or_ensure?(node)
@@ -137,7 +156,7 @@ module RuboCop
             return node if node
           end
 
-          return last_heredoc_argument(n.receiver) if n.respond_to?(:receiver)
+          last_heredoc_argument(n.receiver) if n.respond_to?(:receiver)
         end
 
         def last_heredoc_argument_node(node)
@@ -145,6 +164,8 @@ module RuboCop
 
           if node.if_branch.and_type?
             node.if_branch.children.first
+          elsif use_heredoc_in_condition?(node.condition)
+            node.condition
           else
             node.if_branch.children.last
           end
@@ -161,6 +182,12 @@ module RuboCop
           node.respond_to?(:heredoc?) && node.heredoc?
         end
 
+        def use_heredoc_in_condition?(condition)
+          condition.descendants.any? do |descendant|
+            descendant.respond_to?(:heredoc?) && descendant.heredoc?
+          end
+        end
+
         def offense_location(node)
           if node.loc.respond_to?(:end) && node.loc.end
             node.loc.end
@@ -175,6 +202,12 @@ module RuboCop
 
           parent.begin_type? && parent.single_line?
         end
+
+        # SimpleCov excludes code from the coverage report by wrapping it in `# :nocov:`:
+        # https://github.com/simplecov-ruby/simplecov#ignoringskipping-code
+        def simplecov_directive_comment?(comment)
+          SIMPLE_DIRECTIVE_COMMENT_PATTERN.match?(comment.text)
+        end
       end
     end
   end

data/lib/rubocop/cop/layout/empty_line_after_magic_comment.rb

@@ -27,9 +27,9 @@ module RuboCop
         MSG = 'Add an empty line after magic comments.'
 
         def on_new_investigation
-          return unless processed_source.ast &&
-                        (last_magic_comment = last_magic_comment(processed_source))
-          return if processed_source[last_magic_comment.loc.line].strip.empty?
+          return unless (last_magic_comment = last_magic_comment(processed_source))
+          return unless (next_line = processed_source[last_magic_comment.loc.line])
+          return if next_line.strip.empty?
 
           offending_range = offending_range(last_magic_comment)
 
@@ -46,18 +46,25 @@ module RuboCop
 
         # Find the last magic comment in the source file.
         #
-        # Take all comments that precede the first line of code, select the
+        # Take all comments that precede the first line of code (or just take
+        # them all in the case when there is no code), select the
         # magic comments, and return the last magic comment in the file.
         #
         # @return [Parser::Source::Comment] if magic comments exist before code
         # @return [nil] otherwise
         def last_magic_comment(source)
-          source
-            .comments
-            .take_while { |comment| comment.loc.line < source.ast.loc.line }
+          comments_before_code(source)
             .reverse
             .find { |comment| MagicComment.parse(comment.text).any? }
         end
+
+        def comments_before_code(source)
+          if source.ast
+            source.comments.take_while { |comment| comment.loc.line < source.ast.loc.line }
+          else
+            source.comments
+          end
+        end
       end
     end
   end

data/lib/rubocop/cop/layout/empty_line_between_defs.rb

@@ -135,7 +135,8 @@ module RuboCop
           return if nodes.all?(&:single_line?) && cop_config['AllowAdjacentOneLineDefs']
 
           correction_node = nodes.last
-          location = correction_node.loc.keyword.join(correction_node.loc.name)
+
+          location = def_location(correction_node)
           add_offense(location, message: message(correction_node, count: count)) do |corrector|
             autocorrect(corrector, *nodes, count)
           end
@@ -159,10 +160,28 @@ module RuboCop
 
         private
 
+        def def_location(correction_node)
+          if correction_node.block_type?
+            correction_node.source_range.join(correction_node.children.first.source_range)
+          else
+            correction_node.loc.keyword.join(correction_node.loc.name)
+          end
+        end
+
         def candidate?(node)
-          return unless node
+          return false unless node
 
-          method_candidate?(node) || class_candidate?(node) || module_candidate?(node)
+          method_candidate?(node) || class_candidate?(node) || module_candidate?(node) ||
+            macro_candidate?(node)
+        end
+
+        def empty_line_between_macros
+          cop_config.fetch('DefLikeMacros', []).map(&:to_sym)
+        end
+
+        def macro_candidate?(node)
+          node.block_type? && node.children.first.macro? &&
+            empty_line_between_macros.include?(node.children.first.method_name)
         end
 
         def method_candidate?(node)
@@ -226,7 +245,11 @@ module RuboCop
         end
 
         def def_start(node)
-          node.loc.keyword.line
+          if node.block_type? && node.children.first.send_type?
+            node.source_range.line
+          else
+            node.loc.keyword.line
+          end
         end
 
         def def_end(node)

data/lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb

@@ -68,6 +68,8 @@ module RuboCop
           check_body(node.body, node.loc.line)
         end
         alias on_defs on_def
+        alias on_block on_def
+        alias on_numblock on_def
 
         def on_kwbegin(node)
           body, = *node

data/lib/rubocop/cop/layout/end_alignment.rb

@@ -20,7 +20,9 @@ module RuboCop
       # This `Layout/EndAlignment` cop aligns with keywords (e.g. `if`, `while`, `case`)
       # by default. On the other hand, `Layout/BeginEndAlignment` cop aligns with
       # `EnforcedStyleAlignWith: start_of_line` by default due to `||= begin` tends
-      # to align with the start of the line. These style can be configured by each cop.
+      # to align with the start of the line. `Layout/DefEndAlignment` cop also aligns with
+      # `EnforcedStyleAlignWith: start_of_line` by default.
+      # These style can be configured by each cop.
       #
       # @example EnforcedStyleAlignWith: keyword (default)
       #   # bad
@@ -83,7 +85,11 @@ module RuboCop
         end
 
         def on_sclass(node)
-          check_other_alignment(node)
+          if node.parent&.assignment?
+            check_asgn_alignment(node.parent, node)
+          else
+            check_other_alignment(node)
+          end
         end
 
         def on_module(node)
@@ -163,7 +169,13 @@ module RuboCop
           when :keyword
             node
           when :variable
-            alignment_node_for_variable_style(node)
+            align_to = alignment_node_for_variable_style(node)
+
+            while (parent = align_to.parent) && parent.send_type? && same_line?(align_to, parent)
+              align_to = parent
+            end
+
+            align_to
           else
             start_line_range(node)
           end