rubocop 1.71.1 → 1.92.1

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?
@@ -110,6 +111,7 @@ module RuboCop
 
         def require_empty_line?(node)
           return false unless node.respond_to?(:type)
+          return false if node.left_sibling.last_line == node.first_line
 
           !allow_alias?(node) && !attribute_or_allowed_method?(node)
         end

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|
       #
       #     # ...
@@ -28,12 +38,19 @@ module RuboCop
         KIND = 'block'
 
         def on_block(node)
-          first_line = node.send_node.last_line
-
-          check(node, node.body, adjusted_first_line: first_line)
+          check(node, node.body, adjusted_first_line: body_start_line(node))
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
+
+        private
+
+        def body_start_line(node)
+          return node.loc.begin.line unless node.arguments?
+
+          [node.loc.begin.line, node.arguments.last_line].max
+        end
       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_exception_handling_keywords.rb

@@ -85,8 +85,12 @@ module RuboCop
             next if line == line_of_def_or_kwbegin || last_body_and_end_on_same_line?(body)
 
             keyword = loc.source
+
             # below the keyword
-            check_line(style, line, message('after', keyword), &:empty?)
+            unless left_to_block_body_cop?(body, line)
+              check_line(style, line, message('after', keyword), &:empty?)
+            end
+
             # above the keyword
             check_line(style, line - 2, message('before', keyword), &:empty?)
           end
@@ -122,6 +126,15 @@ module RuboCop
           end
         end
 
+        def left_to_block_body_cop?(body, keyword_line)
+          return false unless body.parent.any_block_type?
+
+          cop_config = config.for_enabled_cop('Layout/EmptyLinesAroundBlockBody')
+          return false if cop_config['EnforcedStyle'] != 'empty_lines'
+
+          only_empty_lines_until_end?(body, keyword_line)
+        end
+
         def keyword_locations_in_rescue(node)
           [node.loc.else, *node.resbody_branches.map { |body| body.loc.keyword }].compact
         end
@@ -133,6 +146,15 @@ module RuboCop
             *keyword_locations(rescue_body_without_ensure)
           ]
         end
+
+        def only_empty_lines_until_end?(body, keyword_line)
+          end_line = body.parent.loc.end.line
+          next_line = (keyword_line + 1).upto(end_line).find do |line_number|
+            !processed_source.lines[line_number - 1].strip.empty?
+          end
+
+          next_line == end_line
+        end
       end
     end
   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
@@ -124,11 +124,9 @@ module RuboCop
         end
 
         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?
+          rhs = leading_node(rhs)
+
+          return unless rhs&.conditional?
           return if rhs.if_type? && rhs.ternary?
 
           check_asgn_alignment(node, rhs)
@@ -145,6 +143,16 @@ module RuboCop
           ignore_node(inner_node)
         end
 
+        def leading_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.
+          rhs = first_part_of_call_chain(rhs)
+
+          # If `rhs` is a `begin` node or a logical operator, unwrap to find the leading node.
+          rhs = rhs.child_nodes.first while rhs&.type?(:begin, :or, :and)
+          rhs
+        end
+
         def asgn_variable_align_with(outer_node, inner_node)
           expr = outer_node.source_range
 
@@ -169,13 +177,7 @@ module RuboCop
           when :keyword
             node
           when :variable
-            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
+            alignment_node_for_variable_style(node)
           else
             start_line_range(node)
           end
@@ -201,7 +203,13 @@ module RuboCop
 
         def assignment_or_operator_method(node)
           node.ancestors.find do |ancestor|
-            ancestor.assignment_or_similar? || (ancestor.send_type? && ancestor.operator_method?)
+            if ancestor.assignment_or_similar?
+              leading_node(extract_rhs(ancestor)).equal?(node)
+            elsif ancestor.send_type? && ancestor.operator_method?
+              !leading_node(ancestor).equal?(node)
+            elsif ancestor.send_type?
+              leading_node(ancestor.last_argument).equal?(node)
+            end
           end
         end
       end

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

@@ -36,11 +36,16 @@ module RuboCop
         MSG_UNNECESSARY = 'Unnecessary spacing detected.'
         MSG_UNALIGNED_ASGN = '`=` is not aligned with the %<location>s assignment.'
 
+        def self.autocorrect_incompatible_with
+          [Layout::RedundantLineBreak, Style::SelfAssignment]
+        end
+
         def on_new_investigation
           return if processed_source.blank?
 
           @aligned_comments = aligned_locations(processed_source.comments.map(&:loc))
           @corrected = Set.new if force_equal_sign_alignment?
+          prepare_alignment_data
 
           processed_source.tokens.each_cons(2) do |token1, token2|
             check_tokens(processed_source.ast, token1, token2)
@@ -95,19 +100,120 @@ module RuboCop
           end_pos = token2.begin_pos - 1
           return if end_pos <= start_pos
 
-          return if allow_for_alignment? && aligned_tok?(token2)
+          return if allow_for_alignment? && aligned_tok?(token1, token2)
 
           yield range_between(start_pos, end_pos)
         end
 
-        def aligned_tok?(token)
+        def aligned_tok?(previous_token, token)
           if token.comment?
             @aligned_comments.include?(token.line)
           else
-            aligned_with_something?(token.pos)
+            aligned_with_something?(token.pos) &&
+              (ASSIGNMENT_OR_COMPARISON_TOKENS.include?(token.type) ||
+               spacing_varies?(previous_token, token))
           end
         end
 
+        def spacing_varies?(previous_token, token)
+          by_column, typed = group_profile(token.line)
+          column = token.pos.column
+          lines, spacings = typed[[column, token.type]]
+          entries = by_column[column]
+
+          if lines.size > 1
+            uniform_alignment_allowed?(token, lines, spacings)
+          elsif entries.size > 1
+            distinct_spacings(entries).size > 1
+          else
+            nearest_spacing_varies?(previous_token, token)
+          end
+        end
+
+        def uniform_alignment_allowed?(token, lines, spacings)
+          return @alignment_verdicts[lines] if @alignment_verdicts.key?(lines)
+
+          @alignment_verdicts[lines] =
+            spacings.uniq.size > 1 || aligned_on_other_column?(token, lines)
+        end
+
+        def aligned_on_other_column?(token, lines)
+          line_set = Set.new(lines)
+          by_column, = group_profile(token.line)
+
+          by_column.any? do |column, entries|
+            next false if column == token.pos.column
+
+            shared = entries.filter_map { |line, spacing| spacing if line_set.include?(line) }
+            shared.uniq.size > 1
+          end
+        end
+
+        def distinct_spacings(entries)
+          entries.map(&:last).uniq
+        end
+
+        def group_profile(line_number)
+          group = alignment_lines(line_number)
+
+          @group_profiles[group] ||= build_group_profile(group)
+        end
+
+        def build_group_profile(group)
+          by_column = Hash.new { |hash, key| hash[key] = [] }
+          typed = Hash.new { |hash, key| hash[key] = [[], []] }
+
+          group.each { |line| record_line_spacings(by_column, typed, line) }
+
+          [by_column, typed]
+        end
+
+        def record_line_spacings(by_column, typed, line)
+          @tokens_by_line[line]&.each_cons(2) do |previous_token, token|
+            spacing = token.begin_pos - previous_token.end_pos
+            by_column[token.pos.column] << [line, spacing]
+            lines, spacings = typed[[token.pos.column, token.type]]
+            lines << line
+            spacings << spacing
+          end
+        end
+
+        def nearest_spacing_varies?(previous_token, token)
+          spacing = token.begin_pos - previous_token.end_pos
+          line_ranges = [(token.line - 1).downto(1),
+                         (token.line + 1).upto(processed_source.lines.length)]
+
+          line_ranges.any? do |line_numbers|
+            nearest_spacing_differs?(line_numbers, token, spacing)
+          end
+        end
+
+        def nearest_spacing_differs?(line_numbers, token, spacing)
+          line_numbers.each do |line|
+            break if definition_boundary_lines.include?(line)
+            next if aligned_comment_lines.include?(line)
+
+            other_spacing = spacing_before_token_at(line, token.pos.column)
+            return other_spacing != spacing if other_spacing
+          end
+
+          false
+        end
+
+        def spacing_before_token_at(line_number, column)
+          tokens = @tokens_by_line[line_number]
+          index = tokens&.index { |token| token.pos.column == column }
+          return unless index&.positive?
+
+          tokens[index].begin_pos - tokens[index - 1].end_pos
+        end
+
+        def prepare_alignment_data
+          @group_profiles = {}.compare_by_identity
+          @alignment_verdicts = {}.compare_by_identity
+          @tokens_by_line = processed_source.tokens.group_by(&:line)
+        end
+
         def ignored_range?(ast, start_pos)
           ignored_ranges(ast).any? { |r| r.include?(start_pos) }
         end