rubocop 1.59.0 → 1.65.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,14 +48,15 @@ module RuboCop
           return if node.arguments.none?
           return unless valid_method_name?(node)
 
-          actual_name = node.first_argument.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
@@ -58,44 +67,112 @@ module RuboCop
 
         def method_directives(node)
           comments = processed_source.ast_with_comments[node]
-
-          comments.filter_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] }
+            {
+              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)
 
@@ -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
@@ -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.rb

@@ -20,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/assignment_indentation.rb

@@ -6,6 +6,9 @@ module RuboCop
       # Checks the indentation of the first line of the
       # right-hand-side of a multi-line assignment.
       #
+      # The indentation of the remaining lines can be corrected with
+      # other cops such as `Layout/IndentationConsistency` and `Layout/EndAlignment`.
+      #
       # @example
       #   # bad
       #   value =
@@ -19,8 +22,6 @@ module RuboCop
       #       'bar'
       #     end
       #
-      # The indentation of the remaining lines can be corrected with
-      # other cops such as `IndentationConsistency` and `EndAlignment`.
       class AssignmentIndentation < Base
         include CheckAssignment
         include Alignment

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

@@ -121,7 +121,7 @@ module RuboCop
           return if case_node.single_line?
           return if enforced_style_end? && end_and_last_conditional_same_line?(case_node)
 
-          case_node.each_when { |when_node| check_when(when_node, 'when') }
+          case_node.when_branches.each { |when_node| check_when(when_node, 'when') }
         end
 
         def on_case_match(case_match_node)

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

@@ -160,7 +160,7 @@ module RuboCop
         end
 
         def two_alternatives?(line)
-          /^\s*(else|elsif|when|rescue|ensure)\b/.match?(line)
+          /^\s*(else|elsif|when|in|rescue|ensure)\b/.match?(line)
         end
       end
     end

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

@@ -9,16 +9,12 @@ module RuboCop
       # @example
       #
       #   # bad
-      #
       #   if
       #     some_condition
       #     do_something
       #   end
       #
-      # @example
-      #
       #   # good
-      #
       #   if some_condition
       #     do_something
       #   end

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

@@ -106,7 +106,9 @@ module RuboCop
         end
 
         def concat_consecutive_comments(comments)
-          consecutive_comments = comments.chunk_while { |i, j| i.loc.line.succ == j.loc.line }
+          consecutive_comments = comments.chunk_while do |i, j|
+            i.loc.line.succ == j.loc.line && i.loc.column == j.loc.column
+          end
 
           consecutive_comments.map do |chunk|
             joined_text = chunk.map { |c| comment_text(c) }.join

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

@@ -80,7 +80,7 @@ module RuboCop
         alias on_until_post on_while_post
 
         def on_case(node)
-          node.each_when do |when_node|
+          node.when_branches.each do |when_node|
             last_condition = when_node.conditions.last
 
             next if !multiline_when_condition?(when_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)

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

@@ -118,8 +118,8 @@ module RuboCop
       #
       # @example EnforcedStyle: special_for_inner_method_call
       #   # The first argument should normally be indented one step more than
-      #   # the preceding line, but if it's a argument for a method call that
-      #   # is itself a argument in a method call, then the inner argument
+      #   # the preceding line, but if it's an argument for a method call that
+      #   # is itself an argument in a method call, then the inner argument
       #   # should be indented relative to the inner method.
       #
       #   # good

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

@@ -5,7 +5,10 @@ module RuboCop
     module Layout
       # Checks the indentation of the first element in an array literal
       # where the opening bracket and the first element are on separate lines.
-      # The other elements' indentations are handled by the ArrayAlignment cop.
+      # The other elements' indentations are handled by `Layout/ArrayAlignment` cop.
+      #
+      # This cop will respect `Layout/ArrayAlignment` and will not work when
+      # `EnforcedStyle: with_fixed_indentation` is specified for `Layout/ArrayAlignment`.
       #
       # By default, array literals that are arguments in a method call with
       # parentheses, and where the opening square bracket of the array is on the
@@ -89,10 +92,14 @@ module RuboCop
               'in an array, relative to %<base_description>s.'
 
         def on_array(node)
+          return if style != :consistent && enforce_first_argument_with_fixed_indentation?
+
           check(node, nil) if node.loc.begin
         end
 
         def on_send(node)
+          return if style != :consistent && enforce_first_argument_with_fixed_indentation?
+
           each_argument_node(node, :array) do |array_node, left_parenthesis|
             check(array_node, left_parenthesis)
           end
@@ -174,6 +181,16 @@ module RuboCop
             'where the left bracket is.'
           end
         end
+
+        def enforce_first_argument_with_fixed_indentation?
+          return false unless array_alignment_config['Enabled']
+
+          array_alignment_config['EnforcedStyle'] == 'with_fixed_indentation'
+        end
+
+        def array_alignment_config
+          config.for_cop('Layout/ArrayAlignment')
+        end
       end
     end
   end

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

@@ -6,7 +6,7 @@ module RuboCop
       # Checks the indentation of the here document bodies. The bodies
       # are indented one step.
       #
-      # Note: When ``Layout/LineLength``'s `AllowHeredoc` is false (not default),
+      # NOTE: When ``Layout/LineLength``'s `AllowHeredoc` is false (not default),
       #       this cop does not add any offenses for long here documents to
       #       avoid ``Layout/LineLength``'s offenses.
       #

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

@@ -136,7 +136,7 @@ module RuboCop
         alias on_until on_while
 
         def on_case(case_node)
-          case_node.each_when do |when_node|
+          case_node.when_branches.each do |when_node|
             check_indentation(when_node.loc.keyword, when_node.body)
           end
 

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

@@ -107,7 +107,7 @@ module RuboCop
           return false unless line.end_with?("\\\n")
 
           # Ensure backslash isn't part of a token spanning to the next line.
-          node.children.none? { |c| c.first_line == line_num && c.multiline? }
+          node.children.none? { |c| (c.first_line...c.last_line).cover?(line_num) && c.multiline? }
         end
 
         def autocorrect(corrector, offense_range, insert_pos, spaces)

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

@@ -17,29 +17,29 @@ module RuboCop
       # split across lines. These include arrays, hashes, and
       # method calls with argument lists.
       #
-      # If autocorrection is enabled, the following Layout cops
+      # If autocorrection is enabled, the following cops
       # are recommended to further format the broken lines.
       # (Many of these are enabled by default.)
       #
-      # * ArgumentAlignment
-      # * ArrayAlignment
-      # * BlockAlignment
-      # * BlockDelimiters
-      # * BlockEndNewline
-      # * ClosingParenthesisIndentation
-      # * FirstArgumentIndentation
-      # * FirstArrayElementIndentation
-      # * FirstHashElementIndentation
-      # * FirstParameterIndentation
-      # * HashAlignment
-      # * IndentationWidth
-      # * MultilineArrayLineBreaks
-      # * MultilineBlockLayout
-      # * MultilineHashBraceLayout
-      # * MultilineHashKeyLineBreaks
-      # * MultilineMethodArgumentLineBreaks
-      # * MultilineMethodParameterLineBreaks
-      # * ParameterAlignment
+      # * `Layout/ArgumentAlignment`
+      # * `Layout/ArrayAlignment`
+      # * `Layout/BlockAlignment`
+      # * `Layout/BlockEndNewline`
+      # * `LayoutClosingParenthesisIndentation`
+      # * `LayoutFirstArgumentIndentation`
+      # * `LayoutFirstArrayElementIndentation`
+      # * `LayoutFirstHashElementIndentation`
+      # * `LayoutFirstParameterIndentation`
+      # * `LayoutHashAlignment`
+      # * `LayoutIndentationWidth`
+      # * `LayoutMultilineArrayLineBreaks`
+      # * `LayoutMultilineBlockLayout`
+      # * `LayoutMultilineHashBraceLayout`
+      # * `LayoutMultilineHashKeyLineBreaks`
+      # * `LayoutMultilineMethodArgumentLineBreaks`
+      # * `LayoutMultilineMethodParameterLineBreaks`
+      # * `Layout/ParameterAlignment`
+      # * `Style/BlockDelimiters`
       #
       # Together, these cops will pretty print hashes, arrays,
       # method calls, etc. For example, let's say the max columns

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

@@ -84,8 +84,20 @@ module RuboCop
         end
 
         def offense?(node)
-          node.multiline? && !too_long?(node) && suitable_as_single_line?(node) &&
-            !configured_to_not_be_inspected?(node)
+          return false if !node.multiline? || too_long?(node) || !suitable_as_single_line?(node)
+          return require_backslash?(node) if node.and_type? || node.or_type?
+
+          !index_access_call_chained?(node) && !configured_to_not_be_inspected?(node)
+        end
+
+        def require_backslash?(node)
+          processed_source.lines[node.loc.operator.line - 1].end_with?('\\')
+        end
+
+        def index_access_call_chained?(node)
+          return false unless node.send_type? && node.method?(:[])
+
+          node.children.first.send_type? && node.children.first.method?(:[])
         end
 
         def configured_to_not_be_inspected?(node)

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

@@ -180,6 +180,9 @@ module RuboCop
           with_space = range_with_surrounding_space(operator)
           return if with_space.source.start_with?("\n")
 
+          comment = processed_source.comment_at_line(operator.line)
+          return if comment && with_space.last_column == comment.loc.column
+
           offense(type, operator, with_space, right_operand) do |msg|
             add_offense(operator, message: msg) do |corrector|
               autocorrect(corrector, with_space, right_operand)

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

@@ -81,19 +81,28 @@ module RuboCop
         private
 
         def check_empty(left_brace, space_plus_brace, used_style)
-          return if style_for_empty_braces == used_style
-
-          config_to_allow_offenses['EnforcedStyleForEmptyBraces'] = used_style.to_s
+          if style_for_empty_braces == used_style
+            handle_different_styles_for_empty_braces(used_style)
+            return
+          elsif !config_to_allow_offenses.key?('Enabled')
+            config_to_allow_offenses['EnforcedStyleForEmptyBraces'] = used_style.to_s
+          end
 
           if style_for_empty_braces == :space
-            add_offense(left_brace, message: MISSING_MSG) do |corrector|
-              autocorrect(corrector, left_brace)
-            end
+            range = left_brace
+            msg = MISSING_MSG
           else
-            space = range_between(space_plus_brace.begin_pos, left_brace.begin_pos)
-            add_offense(space, message: DETECTED_MSG) do |corrector|
-              autocorrect(corrector, space)
-            end
+            range = range_between(space_plus_brace.begin_pos, left_brace.begin_pos)
+            msg = DETECTED_MSG
+          end
+          add_offense(range, message: msg) { |corrector| autocorrect(corrector, range) }
+        end
+
+        def handle_different_styles_for_empty_braces(used_style)
+          if config_to_allow_offenses['EnforcedStyleForEmptyBraces'] &&
+             config_to_allow_offenses['EnforcedStyleForEmptyBraces'].to_sym != used_style
+            config_to_allow_offenses.clear
+            config_to_allow_offenses['Enabled'] = false
           end
         end
 

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

@@ -116,7 +116,7 @@ module RuboCop
 
         def incorrect_style_detected(token1, token2,
                                      expect_space, is_empty_braces)
-          brace = (token1.text == '{' ? token1 : token2).pos
+          brace = (token1.left_brace? ? token1 : token2).pos
           range = expect_space ? brace : space_range(brace)
           detected_style = expect_space ? 'no_space' : 'space'
 

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

@@ -25,8 +25,7 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        NO_SPACE_MSG = 'Space inside string interpolation detected.'
-        SPACE_MSG = 'Missing space inside string interpolation detected.'
+        MSG = '%<command>s space inside string interpolation.'
 
         def on_interpolation(begin_node)
           return if begin_node.multiline?
@@ -36,9 +35,9 @@ module RuboCop
           return if empty_brackets?(left, right, tokens: tokens)
 
           if style == :no_space
-            no_space_offenses(begin_node, left, right, NO_SPACE_MSG)
+            no_space_offenses(begin_node, left, right, MSG)
           else
-            space_offenses(begin_node, left, right, SPACE_MSG)
+            space_offenses(begin_node, left, right, MSG)
           end
         end