rubocop 1.57.1 → 1.81.6

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
@@ -149,7 +155,8 @@ module RuboCop
           newline_pos = source_buffer.source.index("\n", end_pos)
 
           # Handle the case when multiple one-liners are on the same line.
-          newline_pos = end_pos + 1 if newline_pos > node.source_range.begin_pos
+          begin_pos = node.source_range.begin_pos
+          newline_pos = begin_pos - 1 if newline_pos > begin_pos
 
           if count > maximum_empty_lines
             autocorrect_remove_lines(corrector, newline_pos, count)
@@ -161,8 +168,10 @@ module RuboCop
         private
 
         def def_location(correction_node)
-          if correction_node.block_type?
+          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
@@ -180,12 +189,18 @@ module RuboCop
         end
 
         def macro_candidate?(node)
-          node.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.def_type? || node.defs_type?)
+          cop_config['EmptyLineBetweenMethodDefs'] && node.any_def_type?
         end
 
         def class_candidate?(node)
@@ -245,7 +260,9 @@ module RuboCop
         end
 
         def def_start(node)
-          if node.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
@@ -257,11 +274,7 @@ module RuboCop
         end
 
         def end_loc(node)
-          if (node.def_type? || node.defs_type?) && node.endless?
-            node.source_range.end
-          else
-            node.loc.end
-          end
+          node.source_range.end
         end
 
         def autocorrect_remove_lines(corrector, newline_pos, count)
@@ -282,6 +295,8 @@ module RuboCop
           case node.type
           when :def, :defs
             :method
+          when :numblock, :itblock
+            :block
           else
             node.type
           end

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)
+
+          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.if_type?
+
+          node.right_sibling
+        end
+      end
+    end
+  end
+end

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

@@ -83,17 +83,18 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
-        def on_send(node) # rubocop:disable Metrics/CyclomaticComplexity
-          return unless node.bare_access_modifier? &&
-                        !(node.parent&.block_type? || node.parent&.numblock_type?)
+        def on_send(node)
+          return unless node.bare_access_modifier? && !node.block_literal?
+          return if same_line?(node, node.right_sibling)
           return if expected_empty_lines?(node)
 
           message = message(node)
           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_begin_body.rb

@@ -8,19 +8,18 @@ module RuboCop
       #
       # @example
       #
-      #   # good
-      #
+      #   # bad
       #   begin
+      #
       #     # ...
-      #   end
       #
-      #   # bad
+      #   end
       #
+      #   # good
       #   begin
-      #
       #     # ...
-      #
       #   end
+      #
       class EmptyLinesAroundBeginBody < Base
         include EmptyLinesAroundBody
         extend AutoCorrector

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

@@ -34,6 +34,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

@@ -71,7 +71,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

@@ -6,7 +6,7 @@ module RuboCop
       # Checks if empty lines exist around the bodies of `begin`
       # sections. This cop doesn't check empty lines at `begin` body
       # beginning/end and around method definition body.
-      # `Style/EmptyLinesAroundBeginBody` or `Style/EmptyLinesAroundMethodBody`
+      # `Layout/EmptyLinesAroundBeginBody` or `Layout/EmptyLinesAroundMethodBody`
       # can be used for this purpose.
       #
       # @example
@@ -72,8 +72,7 @@ module RuboCop
         alias on_numblock on_def
 
         def on_kwbegin(node)
-          body, = *node
-          check_body(body, node.loc.line)
+          check_body(node.children.first, node.loc.line)
         end
 
         private
@@ -83,7 +82,7 @@ module RuboCop
 
           locations.each do |loc|
             line = loc.line
-            next if line == line_of_def_or_kwbegin || last_rescue_and_end_on_same_line(body)
+            next if line == line_of_def_or_kwbegin || last_body_and_end_on_same_line?(body)
 
             keyword = loc.source
             # below the keyword
@@ -93,8 +92,13 @@ module RuboCop
           end
         end
 
-        def last_rescue_and_end_on_same_line(body)
-          body.rescue_type? && body.resbody_branches.last.loc.line == body.parent.loc.end.line
+        def last_body_and_end_on_same_line?(body)
+          end_keyword_line = body.parent.loc.end.line
+          return body.loc.last_line == end_keyword_line unless body.rescue_type?
+
+          last_body_line = body.else? ? body.loc.else.line : body.resbody_branches.last.loc.line
+
+          last_body_line == end_keyword_line
         end
 
         def message(location, keyword)
@@ -123,10 +127,10 @@ module RuboCop
         end
 
         def keyword_locations_in_ensure(node)
-          ensure_body, = *node
+          rescue_body_without_ensure = node.children.first
           [
             node.loc.keyword,
-            *keyword_locations(ensure_body)
+            *keyword_locations(rescue_body_without_ensure)
           ]
         end
       end

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

@@ -27,7 +27,14 @@ module RuboCop
         KIND = 'method'
 
         def on_def(node)
-          check(node, node.body)
+          if node.endless?
+            return unless offending_endless_method?(node)
+
+            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
 
@@ -36,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/end_alignment.rb

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

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

@@ -49,19 +49,13 @@ module RuboCop
 
         private
 
-        def aligned_locations(locs) # rubocop:disable Metrics/AbcSize
+        def aligned_locations(locs)
           return [] if locs.empty?
 
-          aligned = Set[locs.first.line, locs.last.line]
-          locs.each_cons(3) do |before, loc, after|
-            col = loc.column
-            aligned << loc.line if col == before.column || col == after.column
+          aligned = Set.new
+          locs.each_cons(2) do |loc1, loc2|
+            aligned << loc1.line << loc2.line if loc1.column == loc2.column
           end
-
-          # if locs.size > 2 and the size of variable `aligned`
-          # has not increased from its initial value, there are not aligned lines.
-          return [] if locs.size > 2 && aligned.size == 2
-
           aligned
         end
 
@@ -76,7 +70,7 @@ module RuboCop
         end
 
         def check_assignment(token)
-          return unless aligned_with_preceding_assignment(token) == :no
+          return unless aligned_with_preceding_equals_operator(token) == :no
 
           message = format(MSG_UNALIGNED_ASGN, location: 'preceding')
           add_offense(token.pos, message: message) do |corrector|

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
@@ -155,7 +155,7 @@ module RuboCop
         def on_send(node)
           return unless should_check?(node)
           return if same_line?(node, node.first_argument)
-          return if style != :consistent && enforce_first_argument_with_fixed_indentation? &&
+          return if enforce_first_argument_with_fixed_indentation? &&
                     !enable_layout_first_method_argument_line_break?
 
           indent = base_indentation(node) + configured_indentation_width
@@ -225,7 +225,7 @@ module RuboCop
 
         def base_range(send_node, arg_node)
           parent = send_node.parent
-          start_node = if parent && (parent.splat_type? || parent.kwsplat_type?)
+          start_node = if parent&.type?(:splat, :kwsplat)
                          send_node.parent
                        else
                          send_node
@@ -269,17 +269,12 @@ module RuboCop
         end
 
         def enforce_first_argument_with_fixed_indentation?
-          return false unless argument_alignment_config['Enabled']
-
+          argument_alignment_config = config.for_enabled_cop('Layout/ArgumentAlignment')
           argument_alignment_config['EnforcedStyle'] == 'with_fixed_indentation'
         end
 
         def enable_layout_first_method_argument_line_break?
-          config.for_cop('Layout/FirstMethodArgumentLineBreak')['Enabled']
-        end
-
-        def argument_alignment_config
-          config.for_cop('Layout/ArgumentAlignment')
+          config.cop_enabled?('Layout/FirstMethodArgumentLineBreak')
         end
       end
     end