rubocop 1.71.1 → 1.92.1

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

@@ -44,16 +44,26 @@ module RuboCop
           message = message(condition)
 
           add_offense(condition, message: message) do |corrector|
-            range = range_by_whole_lines(condition.source_range, include_final_newline: true)
-
             corrector.insert_after(condition.parent.loc.keyword, " #{condition.source}")
-            corrector.remove(range)
+            corrector.remove(removal_range(node, condition))
           end
         end
 
         def message(condition)
           format(MSG, keyword: condition.parent.keyword)
         end
+
+        # When a body statement shares the condition's line (e.g. `while\n cond; body\nend`),
+        # removing the whole line would delete the body too. In that case only remove the
+        # condition and its trailing separator, preserving the body statement.
+        def removal_range(node, condition)
+          body = node.body
+          if body && body.source_range.line == condition.source_range.last_line
+            range_between(condition.source_range.begin_pos, body.source_range.begin_pos)
+          else
+            range_by_whole_lines(condition.source_range, include_final_newline: true)
+          end
+        end
       end
     end
   end

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

@@ -48,7 +48,11 @@ module RuboCop
         def on_send(node)
           return unless node.def_modifier?
 
-          method_def = node.each_descendant(:def, :defs).first
+          method_def = node.each_descendant(:any_def).first
+          # A single-line `def` has nothing to align, even when a line
+          # continuation puts it on a later line than the modifier.
+          return if method_def.single_line?
+
           expr = node.source_range
 
           line_start = range_between(expr.begin_pos, method_def.loc.keyword.end_pos)

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

@@ -27,10 +27,6 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        def self.autocorrect_incompatible_with
-          [Style::RedundantSelf]
-        end
-
         def on_send(node)
           return unless node.dot? || node.safe_navigation?
 
@@ -46,21 +42,35 @@ module RuboCop
 
         private
 
+        # The dot and the gap it moves across are replaced in one action, so that another
+        # correction that rewrites a range spanning the dot clashes with this one instead of
+        # leaving the moved dot behind.
         def autocorrect(corrector, dot, node)
-          dot_range = if processed_source[dot.line - 1].strip == '.'
-                        range_by_whole_lines(dot, include_final_newline: true)
-                      else
-                        dot
-                      end
-          corrector.remove(dot_range)
-          case style
-          when :leading
-            corrector.insert_before(selector_range(node), dot.source)
-          when :trailing
-            corrector.insert_after(node.receiver, dot.source)
+          dot_range = removed_dot_range(dot)
+
+          if style == :leading
+            move_dot_before_selector(corrector, dot, dot_range, selector_range(node))
+          else
+            move_dot_after_receiver(corrector, dot, dot_range, node.receiver)
           end
         end
 
+        def removed_dot_range(dot)
+          return dot unless processed_source[dot.line - 1].strip == '.'
+
+          range_by_whole_lines(dot, include_final_newline: true)
+        end
+
+        def move_dot_before_selector(corrector, dot, dot_range, selector)
+          gap = range_between(dot_range.end_pos, selector.begin_pos)
+          corrector.replace(dot_range.join(gap), "#{gap.source}#{dot.source}")
+        end
+
+        def move_dot_after_receiver(corrector, dot, dot_range, receiver)
+          gap = range_between(receiver.source_range.end_pos, dot_range.begin_pos)
+          corrector.replace(gap.join(dot_range), "#{dot.source}#{gap.source}")
+        end
+
         def message(dot)
           "Place the #{dot.source} on the " +
             case style
@@ -112,7 +122,7 @@ module RuboCop
         end
 
         def last_heredoc_line(node)
-          if node.send_type?
+          if node.call_type?
             node.arguments.select { |arg| heredoc?(arg) }.map { |arg| arg.loc.heredoc_end.line }.max
           elsif heredoc?(node)
             node.loc.heredoc_end.line
@@ -120,7 +130,7 @@ module RuboCop
         end
 
         def heredoc?(node)
-          node.type?(:str, :dstr) && node.heredoc?
+          node.any_str_type? && node.heredoc?
         end
 
         def end_range(node)

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

@@ -49,7 +49,7 @@ module RuboCop
         end
 
         def on_rescue(node)
-          return unless node.loc.respond_to?(:else) && node.loc.else
+          return unless node.loc?(:else)
 
           check_alignment(base_range_of_rescue(node), node.loc.else)
         end
@@ -92,13 +92,8 @@ module RuboCop
           case parent.type
           when :def, :defs then base_for_method_definition(parent)
           when :kwbegin then parent.loc.begin
-          when :block
-            assignment_node = assignment_node(parent)
-            if same_line?(parent, assignment_node)
-              assignment_node.source_range
-            else
-              parent.send_node.source_range
-            end
+          when :block, :numblock, :itblock then start_line_range(parent)
+          when :class, :module, :sclass then parent.loc.keyword
           else node.loc.keyword
           end
         end
@@ -143,13 +138,6 @@ module RuboCop
             autocorrect(corrector, else_range)
           end
         end
-
-        def assignment_node(node)
-          assignment_node = node.ancestors.first
-          return unless assignment_node&.assignment?
-
-          assignment_node
-        end
       end
     end
   end

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

@@ -95,8 +95,7 @@ module RuboCop
         end
 
         def autocorrect(corrector, node)
-          previous_token = previous_token(node)
-          range = if previous_token && same_line?(node, previous_token)
+          range = if inline_comment?(node)
                     range_with_surrounding_space(node.source_range, newlines: false)
                   else
                     range_by_whole_lines(node.source_range, include_final_newline: true)
@@ -138,14 +137,13 @@ module RuboCop
           cop_config['AllowMarginComment']
         end
 
-        def current_token(comment)
-          processed_source.tokens.find { |token| token.pos == comment.source_range }
-        end
-
-        def previous_token(node)
-          current_token = current_token(node)
-          index = processed_source.tokens.index(current_token)
-          index.zero? ? nil : processed_source.tokens[index - 1]
+        # A comment is inline when code precedes it on the same line. Detecting this
+        # from the source (rather than the token stream) is required because, for a
+        # comment trailing a heredoc opener, the preceding token is the heredoc end on
+        # a later line, which would wrongly trigger whole-line removal of the opener.
+        def inline_comment?(comment)
+          preceding_source = processed_source.lines[comment.loc.line - 1][0...comment.loc.column]
+          !preceding_source.strip.empty?
         end
       end
     end

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

@@ -5,8 +5,10 @@ module RuboCop
     module Layout
       # 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:`:
+      # This cop allows a SimpleCov directive comment after guard clause because
+      # SimpleCov excludes code from the coverage report by wrapping it in such directives.
+      # Both the legacy `# :nocov:` comment and the newer `# simplecov:disable` /
+      # `# simplecov:enable` comments are recognized:
       #
       # [source,ruby]
       # ----
@@ -16,6 +18,13 @@ module RuboCop
       #   # :nocov:
       #   bar
       # end
+      #
+      # def foo
+      #   # simplecov:disable
+      #   return if condition
+      #   # simplecov:enable
+      #   bar
+      # end
       # ----
       #
       # Refer to SimpleCov's documentation for more details:
@@ -58,7 +67,12 @@ module RuboCop
 
         MSG = 'Add empty line after guard clause.'
         END_OF_HEREDOC_LINE = 1
-        SIMPLE_DIRECTIVE_COMMENT_PATTERN = /\A# *:nocov:\z/.freeze
+        SIMPLECOV_COMMENT_PATTERN = /\A#\s*(?::nocov:|simplecov\s*:\s*(?:disable|enable)\b)/.freeze
+
+        # @!method guard_clause_branch?(node)
+        def_node_matcher :guard_clause_branch?, <<~PATTERN
+          {(send nil? {:raise :fail} ...) return break next}
+        PATTERN
 
         def on_if(node)
           return if correct_style?(node)
@@ -97,14 +111,16 @@ module RuboCop
         end
 
         def correct_style?(node)
-          !contains_guard_clause?(node) ||
+          !node.if_branch&.guard_clause? ||
             next_line_rescue_or_ensure?(node) ||
             next_sibling_parent_empty_or_else?(node) ||
             next_sibling_empty_or_guard_clause?(node)
         end
 
         def contains_guard_clause?(node)
-          node.if_branch&.guard_clause?
+          return false unless (branch = node.if_branch)
+
+          branch.guard_clause? || guard_clause_branch?(branch)
         end
 
         def next_line_empty_or_allowed_directive_comment?(line)
@@ -131,7 +147,7 @@ module RuboCop
 
         def next_sibling_parent_empty_or_else?(node)
           next_sibling = node.right_sibling
-          return true if next_sibling.nil?
+          return true unless next_sibling.is_a?(AST::Node)
 
           parent = next_sibling.parent
 
@@ -145,8 +161,10 @@ module RuboCop
           next_sibling.if_type? && contains_guard_clause?(next_sibling)
         end
 
+        # rubocop:disable-next Metrics/CyclomaticComplexity
         def last_heredoc_argument(node)
           n = last_heredoc_argument_node(node)
+          n = n.children.first while n.respond_to?(:begin_type?) && n.begin_type?
 
           return n if heredoc?(n)
           return unless n.respond_to?(:arguments)
@@ -189,7 +207,7 @@ module RuboCop
         end
 
         def offense_location(node)
-          if node.loc.respond_to?(:end) && node.loc.end
+          if node.loc?(:end)
             node.loc.end
           else
             node
@@ -203,10 +221,10 @@ module RuboCop
           parent.begin_type? && same_line?(node, node.right_sibling)
         end
 
-        # SimpleCov excludes code from the coverage report by wrapping it in `# :nocov:`:
+        # SimpleCov excludes code from the coverage report by wrapping it in directive comments:
         # https://github.com/simplecov-ruby/simplecov#ignoringskipping-code
         def simplecov_directive_comment?(comment)
-          SIMPLE_DIRECTIVE_COMMENT_PATTERN.match?(comment.text)
+          SIMPLECOV_COMMENT_PATTERN.match?(comment.text)
         end
       end
     end

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

@@ -5,6 +5,14 @@ module RuboCop
     module Layout
       # Checks for a newline after the final magic comment.
       #
+      # `NumberOfEmptyLines` configures the minimum number of empty lines required. Set it
+      # to `2` when using YARD, which otherwise treats the magic comments as documentation
+      # for the first module or class in the file.
+      #
+      # NOTE: `Layout/EmptyLines` has to be disabled for values greater than `1`, as it
+      # removes the extra empty lines this cop adds, and autocorrecting with both enabled
+      # loops between them.
+      #
       # @example
       #   # good
       #   # frozen_string_literal: true
@@ -20,30 +28,80 @@ module RuboCop
       #   class Person
       #     # Some code
       #   end
+      #
+      # @example NumberOfEmptyLines: 1 (default)
+      #   # good
+      #   # frozen_string_literal: true
+      #
+      #   class Person
+      #   end
+      #
+      # @example NumberOfEmptyLines: 2
+      #   # bad
+      #   # frozen_string_literal: true
+      #
+      #   class Person
+      #   end
+      #
+      #   # good
+      #   # frozen_string_literal: true
+      #
+      #
+      #   class Person
+      #   end
       class EmptyLineAfterMagicComment < Base
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Add an empty line after magic comments.'
+        MSG = 'Expected at least %<expected>d empty %<lines>s after magic comments; found ' \
+              '%<actual>d.'
+
+        def validate_config
+          return if number_of_empty_lines.is_a?(Integer) && number_of_empty_lines.positive?
+
+          raise ValidationError,
+                'The `Layout/EmptyLineAfterMagicComment` cop only accepts a positive ' \
+                'integer for its `NumberOfEmptyLines` configuration parameter, but ' \
+                "`#{number_of_empty_lines.inspect}` was given."
+        end
 
         def on_new_investigation
           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?
+
+          actual = empty_lines_after(last_magic_comment)
+          # Trailing empty lines are `Layout/TrailingEmptyLines`' responsibility.
+          return unless processed_source[last_magic_comment.loc.line + actual]
+          return if actual >= number_of_empty_lines
 
           offending_range = offending_range(last_magic_comment)
 
-          add_offense(offending_range) do |corrector|
-            corrector.insert_before(offending_range, "\n")
+          add_offense(offending_range, message: message(actual)) do |corrector|
+            corrector.insert_before(offending_range, "\n" * (number_of_empty_lines - actual))
           end
         end
 
         private
 
+        def message(actual)
+          format(MSG, expected: number_of_empty_lines, actual: actual,
+                      lines: number_of_empty_lines == 1 ? 'line' : 'lines')
+        end
+
+        def empty_lines_after(last_magic_comment)
+          first_line = last_magic_comment.loc.line
+          count = 0
+          count += 1 while (line = processed_source[first_line + count]) && line.strip.empty?
+          count
+        end
+
         def offending_range(last_magic_comment)
           source_range(processed_source.buffer, last_magic_comment.loc.line + 1, 0)
         end
 
+        def number_of_empty_lines
+          cop_config.fetch('NumberOfEmptyLines', 1)
+        end
+
         # Find the last magic comment in the source file.
         #
         # Take all comments that precede the first line of code (or just take

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

@@ -61,21 +61,23 @@ module RuboCop
           return if node.ternary?
 
           if node.modifier_form?
-            check_condition(node.condition) if node.right_sibling
+            check_condition(node.condition, node.right_sibling) if followed_by_statement?(node)
           else
-            check_condition(node.condition)
+            check_condition(node.condition, node.if_branch)
           end
         end
 
         def on_while(node)
-          check_condition(node.condition)
+          return if node.modifier_form? && !followed_by_statement?(node)
+
+          check_condition(node.condition, node.modifier_form? ? node.right_sibling : node.body)
         end
         alias on_until on_while
 
         def on_while_post(node)
-          return unless node.right_sibling
+          return unless followed_by_statement?(node)
 
-          check_condition(node.condition)
+          check_condition(node.condition, node.right_sibling)
         end
         alias on_until_post on_while_post
 
@@ -84,7 +86,8 @@ module RuboCop
             last_condition = when_node.conditions.last
 
             next if !multiline_when_condition?(when_node) ||
-                    next_line_empty?(last_condition.last_line)
+                    next_line_empty?(last_condition.last_line) ||
+                    body_on_line?(when_node.body, last_condition.last_line)
 
             add_offense(when_node, &autocorrect(last_condition))
           end
@@ -94,7 +97,8 @@ module RuboCop
           node.resbody_branches.each do |resbody|
             rescued_exceptions = resbody.exceptions
             next if !multiline_rescue_exceptions?(rescued_exceptions) ||
-                    next_line_empty?(rescued_exceptions.last.last_line)
+                    next_line_empty?(rescued_exceptions.last.last_line) ||
+                    body_on_line?(resbody.body, rescued_exceptions.last.last_line)
 
             add_offense(resbody, &autocorrect(rescued_exceptions.last))
           end
@@ -102,9 +106,14 @@ module RuboCop
 
         private
 
-        def check_condition(condition)
+        def followed_by_statement?(node)
+          node.parent&.type?(:begin, :kwbegin) && node.right_sibling
+        end
+
+        def check_condition(condition, following_node)
           return unless condition.multiline?
           return if next_line_empty?(condition.last_line)
+          return if body_on_line?(following_node, condition.last_line)
 
           add_offense(condition, &autocorrect(condition))
         end
@@ -113,6 +122,10 @@ module RuboCop
           processed_source[line].blank?
         end
 
+        def body_on_line?(body, line)
+          body&.first_line == line
+        end
+
         def multiline_when_condition?(when_node)
           when_node.conditions.first.first_line != when_node.conditions.last.last_line
         end

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

@@ -22,8 +22,6 @@ module RuboCop
       #   def b
       #   end
       #
-      # @example
-      #
       #   # good
       #   def a
       #   end
@@ -42,8 +40,6 @@ module RuboCop
       #   def b
       #   end
       #
-      # @example
-      #
       #   # good
       #   class A
       #   end
@@ -65,8 +61,6 @@ module RuboCop
       #   def b
       #   end
       #
-      # @example
-      #
       #   # good
       #   module A
       #   end
@@ -82,28 +76,40 @@ module RuboCop
       #   # good
       #   class ErrorA < BaseError; end
       #   class ErrorB < BaseError; end
-      #   class ErrorC < BaseError; end
       #
       #   # good
       #   class ErrorA < BaseError; end
       #
       #   class ErrorB < BaseError; end
       #
-      #   class ErrorC < BaseError; end
+      #   # good - DefLikeMacros: [memoize]
+      #   memoize :attribute_a
+      #   memoize :attribute_b
+      #
+      #   # good
+      #   memoize :attribute_a
+      #
+      #   memoize :attribute_b
       #
       # @example AllowAdjacentOneLineDefs: false
       #
       #   # bad
       #   class ErrorA < BaseError; end
       #   class ErrorB < BaseError; end
-      #   class ErrorC < BaseError; end
       #
       #   # good
       #   class ErrorA < BaseError; end
       #
       #   class ErrorB < BaseError; end
       #
-      #   class ErrorC < BaseError; end
+      #   # bad - DefLikeMacros: [memoize]
+      #   memoize :attribute_a
+      #   memoize :attribute_b
+      #
+      #   # good
+      #   memoize :attribute_a
+      #
+      #   memoize :attribute_b
       #
       class EmptyLineBetweenDefs < Base
         include RangeHelp
@@ -164,6 +170,8 @@ module RuboCop
         def def_location(correction_node)
           if correction_node.any_block_type?
             correction_node.source_range.join(correction_node.children.first.source_range)
+          elsif correction_node.send_type?
+            correction_node.source_range
           else
             correction_node.loc.keyword.join(correction_node.loc.name)
           end
@@ -177,16 +185,22 @@ module RuboCop
         end
 
         def empty_line_between_macros
-          cop_config.fetch('DefLikeMacros', []).map(&:to_sym)
+          @empty_line_between_macros ||= cop_config.fetch('DefLikeMacros', []).map(&:to_sym).freeze
         end
 
         def macro_candidate?(node)
-          node.any_block_type? && node.children.first.macro? &&
-            empty_line_between_macros.include?(node.children.first.method_name)
+          macro_candidate = if node.any_block_type?
+                              node.send_node
+                            elsif node.send_type?
+                              node
+                            end
+          return false unless macro_candidate
+
+          macro_candidate.macro? && empty_line_between_macros.include?(macro_candidate.method_name)
         end
 
         def method_candidate?(node)
-          cop_config['EmptyLineBetweenMethodDefs'] && node.type?(:def, :defs)
+          cop_config['EmptyLineBetweenMethodDefs'] && node.any_def_type?
         end
 
         def class_candidate?(node)
@@ -246,7 +260,9 @@ module RuboCop
         end
 
         def def_start(node)
-          if node.any_block_type? && node.children.first.send_type?
+          node = node.send_node if node.any_block_type?
+
+          if node.send_type?
             node.source_range.line
           else
             node.loc.keyword.line
@@ -258,11 +274,20 @@ module RuboCop
         end
 
         def end_loc(node)
-          if node.type?(:def, :defs) && node.endless?
-            node.source_range.end
-          else
-            node.loc.end
-          end
+          end_location = node.source_range.end
+          trailing_heredoc_end(node, end_location) || end_location
+        end
+
+        # For an endless method whose body is a heredoc (e.g. `def a = <<~TEXT`), the
+        # node's source range ends at the heredoc opening line, before the heredoc body.
+        # Use the heredoc's closing delimiter so the def's real end is located after the
+        # heredoc and blank-line insertion does not land inside the heredoc body.
+        def trailing_heredoc_end(node, end_location)
+          heredocs = node.each_descendant(:any_str).select(&:heredoc?)
+          return if heredocs.empty?
+
+          heredoc_end = heredocs.map { |heredoc| heredoc.loc.heredoc_end }.max_by(&:end_pos)
+          heredoc_end if heredoc_end.end_pos > end_location.end_pos
         end
 
         def autocorrect_remove_lines(corrector, newline_pos, count)
@@ -283,7 +308,7 @@ module RuboCop
           case node.type
           when :def, :defs
             :method
-          when :numblock
+          when :numblock, :itblock
             :block
           else
             node.type

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

@@ -27,8 +27,7 @@ module RuboCop
 
         def on_new_investigation
           return if processed_source.tokens.empty?
-          # Quick check if we possibly have consecutive blank lines.
-          return unless processed_source.raw_source.include?("\n\n\n")
+          return unless consecutive_blank_lines_possible?
 
           lines = Set.new
           processed_source.tokens.each { |token| lines << token.line }
@@ -42,6 +41,10 @@ module RuboCop
 
         private
 
+        def consecutive_blank_lines_possible?
+          processed_source.buffer.source.include?("\n\n\n")
+        end
+
         def each_extra_empty_line(lines)
           prev_line = 1