rubocop 1.71.1 → 1.91.0

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_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_after_module_inclusion.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks for an empty line after a module inclusion method (`extend`,
+      # `include` and `prepend`), or a group of them.
+      #
+      # @example
+      #   # bad
+      #   class Foo
+      #     include Bar
+      #     attr_reader :baz
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     include Bar
+      #
+      #     attr_reader :baz
+      #   end
+      #
+      #   # also good - multiple module inclusions grouped together
+      #   class Foo
+      #     extend Bar
+      #     include Baz
+      #     prepend Qux
+      #   end
+      #
+      class EmptyLinesAfterModuleInclusion < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Add an empty line after module inclusion.'
+
+        MODULE_INCLUSION_METHODS = %i[include extend prepend].freeze
+
+        RESTRICT_ON_SEND = MODULE_INCLUSION_METHODS
+
+        def on_send(node)
+          return if node.receiver || node.arguments.empty?
+          return if node.parent&.type?(:send, :any_block, :array)
+
+          return if next_line_empty_or_enable_directive_comment?(node.last_line)
+
+          next_line_node = next_line_node(node)
+          return unless require_empty_line?(next_line_node)
+
+          add_offense(node) { |corrector| autocorrect(corrector, node) }
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          node_range = range_by_whole_lines(node.source_range)
+
+          next_line = node_range.last_line + 1
+          if enable_directive_comment?(next_line)
+            node_range = processed_source.comment_at_line(next_line)
+          end
+
+          corrector.insert_after(node_range, "\n")
+        end
+
+        def next_line_empty_or_enable_directive_comment?(line)
+          line_empty?(line) || (enable_directive_comment?(line + 1) && line_empty?(line + 1))
+        end
+
+        def enable_directive_comment?(line)
+          return false unless (comment = processed_source.comment_at_line(line))
+
+          DirectiveComment.new(comment).enabled?
+        end
+
+        def line_empty?(line)
+          processed_source[line].nil? || processed_source[line].blank?
+        end
+
+        def require_empty_line?(node)
+          return false unless node
+
+          !allowed_method?(node)
+        end
+
+        def allowed_method?(node)
+          node = node.body if node.respond_to?(:modifier_form?) && node.modifier_form?
+
+          return false unless node.send_type?
+
+          MODULE_INCLUSION_METHODS.include?(node.method_name)
+        end
+
+        def next_line_node(node)
+          return if node.parent.type?(:if, :rescue, :ensure)
+
+          node.right_sibling
+        end
+      end
+    end
+  end
+end

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

@@ -83,6 +83,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         def on_send(node)
           return unless node.bare_access_modifier? && !node.block_literal?
@@ -93,7 +94,7 @@ module RuboCop
           add_offense(node, message: message) do |corrector|
             line = range_by_whole_lines(node.source_range)
 
-            corrector.insert_before(line, "\n") unless previous_line_empty?(node.first_line)
+            corrector.insert_before(line, "\n") if should_insert_line_before?(node)
 
             correct_next_line_if_denied_style(corrector, node, line)
           end
@@ -115,18 +116,20 @@ module RuboCop
         def allowed_only_before_style?(node)
           if node.special_modifier?
             return true if processed_source[node.last_line] == 'end'
-            return false if next_line_empty?(node.last_line)
+            return false if next_line_empty_and_exists?(node.last_line)
           end
 
           previous_line_empty?(node.first_line)
         end
 
         def correct_next_line_if_denied_style(corrector, node, line)
+          return unless should_insert_line_after?(node)
+
           case style
           when :around
             corrector.insert_after(line, "\n") unless next_line_empty?(node.last_line)
           when :only_before
-            if next_line_empty?(node.last_line)
+            if next_line_empty_and_exists?(node.last_line)
               range = next_empty_line_range(node)
 
               corrector.remove(range)
@@ -135,7 +138,7 @@ module RuboCop
         end
 
         def previous_line_ignoring_comments(processed_source, send_line)
-          processed_source[0..send_line - 2].reverse.find { |line| !comment_line?(line) }
+          processed_source[0..(send_line - 2)].reverse.find { |line| !comment_line?(line) }
         end
 
         def previous_line_empty?(send_line)
@@ -151,6 +154,10 @@ module RuboCop
           body_end?(last_send_line) || next_line.blank?
         end
 
+        def next_line_empty_and_exists?(last_send_line)
+          next_line_empty?(last_send_line) && last_send_line.next != processed_source.lines.size
+        end
+
         def empty_lines_around?(node)
           previous_line_empty?(node.first_line) && next_line_empty?(node.last_line)
         end
@@ -205,6 +212,29 @@ module RuboCop
             format(MSG_BEFORE_FOR_ONLY_BEFORE, modifier: modifier)
           end
         end
+
+        def should_insert_line_before?(node)
+          return false if previous_line_empty?(node.first_line)
+          return true unless inside_block?(node) && no_empty_lines_around_block_body?
+          return true unless node.parent.begin_type?
+
+          node.parent.children.first != node
+        end
+
+        def should_insert_line_after?(node)
+          return true unless inside_block?(node) && no_empty_lines_around_block_body?
+
+          node.parent.children.last != node
+        end
+
+        def inside_block?(node)
+          node.parent.block_type? || (node.parent.begin_type? && node.parent.parent&.block_type?)
+        end
+
+        def no_empty_lines_around_block_body?
+          config.for_enabled_cop('Layout/EmptyLinesAroundBlockBody')['EnforcedStyle'] ==
+            'no_empty_lines'
+        end
       end
     end
   end

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

@@ -62,40 +62,19 @@ module RuboCop
           node.receiver && node.receiver.loc.last_line != node.loc.selector&.line
         end
 
-        def empty_lines(node)
-          lines = processed_lines(node)
-          lines.select! { |code, _| code.empty? }
-          lines.map { |_, line| line }
-        end
-
-        def extra_lines(node)
-          empty_lines(node).each do |line|
-            range = source_range(processed_source.buffer, line, 0)
-            yield(range)
-          end
-        end
-
-        def processed_lines(node)
-          line_numbers(node).each_with_object([]) do |num, array|
-            array << [processed_source.lines[num - 1], num]
+        def extra_lines(node, &block)
+          node.arguments.each do |arg|
+            empty_range_for_starting_point(arg.source_range.begin, &block)
           end
-        end
 
-        def line_numbers(node)
-          inner_lines = []
-          line_nums = node.arguments.each_with_object([]) do |arg_node, lines|
-            lines << outer_lines(arg_node)
-            inner_lines << inner_lines(arg_node) if arg_node.multiline?
-          end
-          line_nums.flatten.uniq - inner_lines.flatten - outer_lines(node)
+          empty_range_for_starting_point(node.loc.end.begin, &block) if node.loc.end
         end
 
-        def inner_lines(node)
-          [node.first_line + 1, node.last_line - 1]
-        end
+        def empty_range_for_starting_point(start)
+          range = range_with_surrounding_space(start, whitespace: true, side: :left)
+          return unless range.last_line - range.first_line > 1
 
-        def outer_lines(node)
-          [node.first_line - 1, node.last_line + 1]
+          yield range.source_buffer.line_range(range.last_line - 1).adjust(end_pos: 1)
         end
       end
     end

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

@@ -66,6 +66,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Add an empty line after attribute accessor.'
+        RESTRICT_ON_SEND = %i[attr_reader attr_writer attr_accessor attr].freeze
 
         def on_send(node)
           return unless node.attribute_accessor?

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

@@ -7,15 +7,25 @@ module RuboCop
       # the configuration.
       #
       # @example EnforcedStyle: no_empty_lines (default)
-      #   # good
+      #   # bad
+      #   foo do |bar|
+      #
+      #     # ...
+      #
+      #   end
       #
+      #   # good
       #   foo do |bar|
       #     # ...
       #   end
       #
       # @example EnforcedStyle: empty_lines
-      #   # good
+      #   # bad
+      #   foo do |bar|
+      #     # ...
+      #   end
       #
+      #   # good
       #   foo do |bar|
       #
       #     # ...
@@ -34,6 +44,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
       end
     end
   end

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

@@ -7,8 +7,16 @@ module RuboCop
       # the configuration.
       #
       # @example EnforcedStyle: no_empty_lines (default)
-      #   # good
+      #   # bad
+      #   class Foo
+      #
+      #     def bar
+      #       # ...
+      #     end
+      #
+      #   end
       #
+      #   # good
       #   class Foo
       #     def bar
       #       # ...
@@ -16,8 +24,14 @@ module RuboCop
       #   end
       #
       # @example EnforcedStyle: empty_lines
-      #   # good
+      #   # bad
+      #   class Foo
+      #     def bar
+      #       # ...
+      #     end
+      #   end
       #
+      #   # good
       #   class Foo
       #
       #     def bar
@@ -71,7 +85,7 @@ module RuboCop
         KIND = 'class'
 
         def on_class(node)
-          first_line = node.parent_class.first_line if node.parent_class
+          first_line = node.parent_class.last_line if node.parent_class
 
           check(node, node.body, adjusted_first_line: first_line)
         end

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

@@ -27,9 +27,14 @@ module RuboCop
         KIND = 'method'
 
         def on_def(node)
-          first_line = node.arguments.source_range&.last_line
+          if node.endless?
+            return unless offending_endless_method?(node)
 
-          check(node, node.body, adjusted_first_line: first_line)
+            register_offense_for_endless_method(node)
+          else
+            first_line = node.arguments.source_range&.last_line
+            check(node, node.body, adjusted_first_line: first_line)
+          end
         end
         alias on_defs on_def
 
@@ -38,6 +43,21 @@ module RuboCop
         def style
           :no_empty_lines
         end
+
+        def offending_endless_method?(node)
+          node.body.first_line > node.loc.assignment.line + 1 &&
+            processed_source.lines[node.loc.assignment.line].empty?
+        end
+
+        def register_offense_for_endless_method(node)
+          range = processed_source.buffer.line_range(node.loc.assignment.line + 1).resize(1)
+
+          msg = message(MSG_EXTRA, 'beginning')
+
+          add_offense(range, message: msg) do |corrector|
+            corrector.remove(range)
+          end
+        end
       end
     end
   end

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

@@ -7,8 +7,16 @@ module RuboCop
       # the configuration.
       #
       # @example EnforcedStyle: no_empty_lines (default)
-      #   # good
+      #   # bad
+      #   module Foo
+      #
+      #     def bar
+      #       # ...
+      #     end
+      #
+      #   end
       #
+      #   # good
       #   module Foo
       #     def bar
       #       # ...
@@ -16,8 +24,14 @@ module RuboCop
       #   end
       #
       # @example EnforcedStyle: empty_lines
-      #   # good
+      #   # bad
+      #   module Foo
+      #     def bar
+      #       # ...
+      #     end
+      #   end
       #
+      #   # good
       #   module Foo
       #
       #     def bar

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

@@ -19,10 +19,10 @@ 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
+      # `EnforcedStyleAlignWith: start_of_line` by default because `||= begin` tends
       # 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.
+      # These styles can be configured by each cop.
       #
       # @example EnforcedStyleAlignWith: keyword (default)
       #   # bad
@@ -123,12 +123,18 @@ module RuboCop
           AlignmentCorrector.align_end(corrector, processed_source, node, alignment_node(node))
         end
 
+        # rubocop:disable-next Metrics/CyclomaticComplexity
         def check_assignment(node, rhs)
           # If there are method calls chained to the right hand side of the
           # assignment, we let rhs be the receiver of those method calls before
           # we check if it's an if/unless/while/until.
           return unless (rhs = first_part_of_call_chain(rhs))
-          return unless rhs.conditional?
+
+          # If `rhs` is a `begin` node or a logical operator,
+          # unwrap to find the leading conditional.
+          rhs = rhs.child_nodes.first while rhs&.type?(:begin, :or, :and)
+
+          return unless rhs&.conditional?
           return if rhs.if_type? && rhs.ternary?
 
           check_asgn_alignment(node, rhs)