rubocop 1.71.1 → 1.88.2

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

@@ -22,6 +22,11 @@ module RuboCop
       # * Private attribute macros (`attr_accessor`, `attr_writer`, `attr_reader`)
       # * Private instance methods
       #
+      # NOTE: Simply enabling the cop with `Enabled: true` will not use
+      # the example order shown below.
+      # To enforce the order of macros like `attr_reader`,
+      # you must define both `ExpectedOrder` *and* `Categories`.
+      #
       # You can configure the following order:
       #
       # [source,yaml]
@@ -44,7 +49,7 @@ module RuboCop
       #      - private_methods
       # ----
       #
-      # Instead of putting all literals in the expected order, is also
+      # Instead of putting all literals in the expected order, it is also
       # possible to group categories of macros. Visibility levels are handled
       # automatically.
       #
@@ -68,6 +73,36 @@ module RuboCop
       #        - extend
       # ----
       #
+      # If you only set `ExpectedOrder`
+      # without defining `Categories`,
+      # macros such as `attr_reader` or `has_many`
+      # will not be recognized as part of a category, and their order will not be validated.
+      # For example, the following will NOT raise any offenses, even if the order is incorrect:
+      #
+      # [source,yaml]
+      # ----
+      # Layout/ClassStructure:
+      #   Enabled: true
+      #   ExpectedOrder:
+      #     - public_attribute_macros
+      #     - initializer
+      # ----
+      #
+      # To make it work as expected, you must also specify `Categories` like this:
+      #
+      # [source,yaml]
+      # ----
+      # Layout/ClassStructure:
+      #   ExpectedOrder:
+      #     - public_attribute_macros
+      #     - initializer
+      #   Categories:
+      #     attribute_macros:
+      #       - attr_reader
+      #       - attr_writer
+      #       - attr_accessor
+      # ----
+      #
       # @safety
       #   Autocorrection is unsafe because class methods and module inclusion
       #   can behave differently, based on which methods or constants have
@@ -188,7 +223,7 @@ module RuboCop
         # @param node to be analysed
         # @return String when the node type is a `:block` then
         #   {classify} recursively with the first children
-        # @return String when the node type is a `:send` then {find_category}
+        # @return String when the node type is a `:send` then {find_send_node_category}
         #   by method name
         # @return String otherwise trying to {humanize_node} of the current node
         def classify(node)
@@ -198,9 +233,10 @@ module RuboCop
           when :block
             classify(node.send_node)
           when :send
-            find_category(node)
+            find_send_node_category(node)
           else
-            humanize_node(node)
+            name = humanize_node(node)
+            find_category(name) || name
           end.to_s
         end
 
@@ -209,9 +245,9 @@ module RuboCop
         # also its visibility.
         # @param node to be analysed.
         # @return [String] with the key category or the `method_name` as string
-        def find_category(node)
+        def find_send_node_category(node)
           name = node.method_name.to_s
-          category, = categories.find { |_, names| names.include?(name) }
+          category = find_category(name)
           key = category || name
           visibility_key =
             if node.def_modifier?
@@ -222,6 +258,12 @@ module RuboCop
           expected_order.include?(visibility_key) ? visibility_key : key
         end
 
+        def find_category(name)
+          name = name.to_s
+          category, = categories.find { |_, names| names.include?(name) }
+          category
+        end
+
         def walk_over_nested_class_definition(class_node)
           class_elements(class_node).each do |node|
             classification = classify(node)
@@ -236,10 +278,14 @@ module RuboCop
 
           return [] unless class_def
 
-          if class_def.type?(:def, :send)
-            [class_def]
-          else
+          # Only a multi-statement body (`begin`/`kwbegin`) wraps several elements; any
+          # single statement (`def`, `send`, `csend`, `if`, ...) is itself the sole element.
+          # Exploding such a node into its children would yield non-node values (e.g. a
+          # method-name `Symbol` from a `csend`) and crash later checks.
+          if class_def.type?(:begin, :kwbegin)
             class_def.children.compact
+          else
+            [class_def]
           end
         end
 
@@ -322,7 +368,7 @@ module RuboCop
         end
 
         def find_heredoc(node)
-          node.each_node(:str, :dstr, :xstr).find(&:heredoc?)
+          node.each_node(:any_str).find(&:heredoc?)
         end
 
         def buffer

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

@@ -155,13 +155,13 @@ module RuboCop
         end
 
         def all_elements_aligned?(elements)
-          elements.flat_map do |e|
-            if e.hash_type?
-              e.each_child_node.map { |child| child.loc.column }
-            else
+          if elements.first.hash_type?
+            elements.first.each_child_node.map { |child| child.loc.column }
+          else
+            elements.flat_map do |e|
               e.loc.column
             end
-          end.uniq.count == 1
+          end.uniq.one?
         end
 
         def first_argument_line(elements)

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

@@ -155,8 +155,15 @@ module RuboCop
 
         def less_indented?(line)
           rule = config.for_cop('Layout/AccessModifierIndentation')['EnforcedStyle'] == 'outdent'
-          access_modifier = 'private|protected|public'
-          /\A\s*(end\b|[)}\]])/.match?(line) || (rule && /\A\s*(#{access_modifier})\b/.match?(line))
+          /\A\s*(end\b|[)}\]])/.match?(line) || (rule && bare_access_modifier?(line))
+        end
+
+        # Only a bare access modifier (the keyword alone on its line) is outdented by
+        # `Layout/AccessModifierIndentation`. An inline modifier such as `private def foo`
+        # keeps the regular method indentation, so a comment above it must not be pushed
+        # one level deeper.
+        def bare_access_modifier?(line)
+          /\A\s*(private|protected|public)\s*(#.*)?\z/.match?(line)
         end
 
         def two_alternatives?(line)

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

@@ -112,7 +112,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 +120,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,7 @@ 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)
           else node.loc.keyword
           end
         end
@@ -143,13 +137,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 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)
@@ -158,6 +176,7 @@ module RuboCop
 
           last_heredoc_argument(n.receiver) if n.respond_to?(:receiver)
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def last_heredoc_argument_node(node)
           return node unless node.respond_to?(:if_branch)
@@ -189,7 +208,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 +222,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_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.if_type?
+
+          node.right_sibling
+        end
+      end
+    end
+  end
+end