rubocop 1.69.0 → 1.79.2

data/lib/rubocop/cop/internal_affairs/single_line_comparison.rb

@@ -34,8 +34,8 @@ module RuboCop
         # @!method single_line_comparison(node)
         def_node_matcher :single_line_comparison, <<~PATTERN
           {
-            (send (send $_receiver {:line :first_line}) {:== :!=} (send _receiver :last_line))
-            (send (send $_receiver :last_line) {:== :!=} (send _receiver {:line :first_line}))
+            (send (call $_receiver {:line :first_line}) {:== :!=} (call _receiver :last_line))
+            (send (call $_receiver :last_line) {:== :!=} (call _receiver {:line :first_line}))
           }
         PATTERN
 
@@ -43,7 +43,8 @@ module RuboCop
           return unless (receiver = single_line_comparison(node))
 
           bang = node.method?(:!=) ? '!' : ''
-          preferred = "#{bang}#{extract_receiver(receiver)}.single_line?"
+          dot = receiver.parent.loc.dot.source
+          preferred = "#{bang}#{extract_receiver(receiver)}#{dot}single_line?"
 
           add_offense(node, message: format(MSG, preferred: preferred)) do |corrector|
             corrector.replace(node, preferred)
@@ -53,7 +54,7 @@ module RuboCop
         private
 
         def extract_receiver(node)
-          node = node.receiver if node.send_type? && %i[loc source_range].include?(node.method_name)
+          node = node.receiver if node.call_type? && %i[loc source_range].include?(node.method_name)
           node.source
         end
       end

data/lib/rubocop/cop/internal_affairs/undefined_config.rb

@@ -10,14 +10,25 @@ module RuboCop
         extend FileFinder
 
         ALLOWED_CONFIGURATIONS = %w[
-          Safe SafeAutoCorrect AutoCorrect Severity StyleGuide Details Reference Include Exclude
+          Safe SafeAutoCorrect AutoCorrect
+          Severity
+          StyleGuide
+          Details
+          Reference References
+          Include Exclude
         ].freeze
         RESTRICT_ON_SEND = %i[[] fetch].freeze
         MSG = '`%<name>s` is not defined in the configuration for `%<cop>s` ' \
               'in `config/default.yml`.'
         CONFIG_PATH = find_file_upwards('config/default.yml', Dir.pwd)
         CONFIG = if CONFIG_PATH
-                   ConfigLoader.load_yaml_configuration(CONFIG_PATH)
+                   begin
+                     original_debug = ConfigLoader.debug
+                     ConfigLoader.debug = false
+                     ConfigLoader.load_yaml_configuration(CONFIG_PATH)
+                   ensure
+                     ConfigLoader.debug = original_debug
+                   end
                  else
                    {}
                  end

data/lib/rubocop/cop/internal_affairs/useless_restrict_on_send.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module InternalAffairs
-      # Check for useless `RESTRICT_ON_SEND`.
+      # Checks for useless `RESTRICT_ON_SEND`.
       #
       # @example
       #   # bad

data/lib/rubocop/cop/internal_affairs.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
 require_relative 'internal_affairs/cop_description'
+require_relative 'internal_affairs/cop_enabled'
 require_relative 'internal_affairs/create_empty_file'
 require_relative 'internal_affairs/empty_line_between_expect_offense_and_correction'
 require_relative 'internal_affairs/example_description'
 require_relative 'internal_affairs/example_heredoc_delimiter'
 require_relative 'internal_affairs/inherit_deprecated_cop_class'
 require_relative 'internal_affairs/lambda_or_proc'
+require_relative 'internal_affairs/location_exists'
 require_relative 'internal_affairs/location_expression'
 require_relative 'internal_affairs/location_line_equality_comparison'
 require_relative 'internal_affairs/method_name_end_with'
@@ -14,9 +16,13 @@ require_relative 'internal_affairs/method_name_equal'
 require_relative 'internal_affairs/node_destructuring'
 require_relative 'internal_affairs/node_first_or_last_argument'
 require_relative 'internal_affairs/node_matcher_directive'
+require_relative 'internal_affairs/node_pattern_groups'
+require_relative 'internal_affairs/node_type_group'
+require_relative 'internal_affairs/node_type_multiple_predicates'
 require_relative 'internal_affairs/node_type_predicate'
 require_relative 'internal_affairs/numblock_handler'
 require_relative 'internal_affairs/offense_location_keyword'
+require_relative 'internal_affairs/on_send_without_on_csend'
 require_relative 'internal_affairs/operator_keyword'
 require_relative 'internal_affairs/processed_source_buffer_name'
 require_relative 'internal_affairs/redundant_context_config_parameter'
@@ -32,19 +38,3 @@ require_relative 'internal_affairs/style_detected_api_use'
 require_relative 'internal_affairs/undefined_config'
 require_relative 'internal_affairs/useless_message_assertion'
 require_relative 'internal_affairs/useless_restrict_on_send'
-
-module RuboCop
-  # Patch in the InternalAffairs specific config values
-  module InternalAffairs
-    def self.inject!
-      path = File.join(ConfigLoader::RUBOCOP_HOME, 'config', 'internal_affairs.yml')
-      hash = ConfigLoader.load_yaml_configuration(path)
-      config = Config.new(hash, path)
-      puts "configuration from #{path}" if ConfigLoader.debug?
-      config = ConfigLoader.merge_with_default(config, path)
-      ConfigLoader.instance_variable_set(:@default_configuration, config)
-    end
-  end
-end
-
-RuboCop::InternalAffairs.inject!

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

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Layout
       # Bare access modifiers (those not applying to specific methods) should be
-      # indented as deep as method definitions, or as deep as the class/module
+      # indented as deep as method definitions, or as deep as the `class`/`module`
       # keyword, depending on configuration.
       #
       # @example EnforcedStyle: indent (default)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # Check that the arguments on a multi-line method definition are aligned.
+      # Check that the arguments on a multi-line method call are aligned.
       #
       # @example EnforcedStyle: with_first_argument (default)
       #   # good
@@ -141,16 +141,10 @@ module RuboCop
         end
 
         def enforce_hash_argument_with_separator?
-          return false unless hash_argument_config['Enabled']
-
           RuboCop::Cop::Layout::HashAlignment::SEPARATOR_ALIGNMENT_STYLES.any? do |style|
-            hash_argument_config[style]&.include?('separator')
+            config.for_enabled_cop('Layout/HashAlignment')[style]&.include?('separator')
           end
         end
-
-        def hash_argument_config
-          config.for_cop('Layout/HashAlignment')
-        end
       end
     end
   end

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

@@ -73,6 +73,7 @@ module RuboCop
         # @!method block_end_align_target?(node, child)
         def_node_matcher :block_end_align_target?, <<~PATTERN
           {assignment?
+           any_def
            splat
            and
            or
@@ -85,6 +86,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         def style_parameter_name
           'EnforcedStyleAlignWith'
@@ -188,7 +190,7 @@ module RuboCop
         # In offense message, we want to show the assignment LHS rather than
         # the entire assignment.
         def find_lhs_node(node)
-          node = node.lhs while node.op_asgn_type? || node.masgn_type?
+          node = node.lhs while node.type?(:op_asgn, :masgn)
           node
         end
 

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

@@ -43,6 +43,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 

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

@@ -3,25 +3,30 @@
 module RuboCop
   module Cop
     module Layout
-      # Checks if the code style follows the ExpectedOrder configuration:
+      # Checks if the code style follows the `ExpectedOrder` configuration:
       #
       # `Categories` allows us to map macro names into a category.
       #
       # Consider an example of code style that covers the following order:
       #
-      # * Module inclusion (include, prepend, extend)
+      # * Module inclusion (`include`, `prepend`, `extend`)
       # * Constants
-      # * Associations (has_one, has_many)
-      # * Public attribute macros (attr_accessor, attr_writer, attr_reader)
-      # * Other macros (validates, validate)
+      # * Associations (`has_one`, `has_many`)
+      # * Public attribute macros (`attr_accessor`, `attr_writer`, `attr_reader`)
+      # * Other macros (`validates`, `validate`)
       # * Public class methods
       # * Initializer
       # * Public instance methods
-      # * Protected attribute macros (attr_accessor, attr_writer, attr_reader)
+      # * Protected attribute macros (`attr_accessor`, `attr_writer`, `attr_reader`)
       # * Protected instance methods
-      # * Private attribute macros (attr_accessor, attr_writer, attr_reader)
+      # * 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]
@@ -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
@@ -236,7 +271,7 @@ module RuboCop
 
           return [] unless class_def
 
-          if class_def.def_type? || class_def.send_type?
+          if class_def.type?(:def, :send)
             [class_def]
           else
             class_def.children.compact
@@ -289,7 +324,7 @@ module RuboCop
         def marked_as_private_constant?(node, name)
           return false unless node.method?(:private_constant)
 
-          node.arguments.any? { |arg| (arg.sym_type? || arg.str_type?) && arg.value == name }
+          node.arguments.any? { |arg| arg.type?(:sym, :str) && arg.value == name }
         end
 
         def end_position_for(node)

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/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

@@ -120,7 +120,7 @@ module RuboCop
         end
 
         def heredoc?(node)
-          (node.str_type? || node.dstr_type?) && node.heredoc?
+          node.type?(:str, :dstr) && 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,7 +92,7 @@ module RuboCop
           case parent.type
           when :def, :defs then base_for_method_definition(parent)
           when :kwbegin then parent.loc.begin
-          when :block
+          when :block, :numblock, :itblock
             assignment_node = assignment_node(parent)
             if same_line?(parent, assignment_node)
               assignment_node.source_range

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

@@ -131,7 +131,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
 
@@ -189,7 +189,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

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
@@ -162,7 +156,7 @@ 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)
           else
             correction_node.loc.keyword.join(correction_node.loc.name)
@@ -181,12 +175,12 @@ module RuboCop
         end
 
         def macro_candidate?(node)
-          node.block_type? && node.children.first.macro? &&
+          node.any_block_type? && node.children.first.macro? &&
             empty_line_between_macros.include?(node.children.first.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)
@@ -246,7 +240,7 @@ module RuboCop
         end
 
         def def_start(node)
-          if node.block_type? && node.children.first.send_type?
+          if node.any_block_type? && node.children.first.send_type?
             node.source_range.line
           else
             node.loc.keyword.line
@@ -258,7 +252,7 @@ module RuboCop
         end
 
         def end_loc(node)
-          if (node.def_type? || node.defs_type?) && node.endless?
+          if node.any_def_type? && node.endless?
             node.source_range.end
           else
             node.loc.end
@@ -283,6 +277,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
+          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,16 +83,18 @@ 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?
+          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
@@ -114,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)
@@ -134,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)
@@ -150,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
@@ -204,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