rubocop 1.66.1 → 1.69.1

data/lib/rubocop/cop/generator.rb

@@ -71,11 +71,17 @@ module RuboCop
                   (send nil? :bad_method ...)
                 PATTERN
 
+                # Called on every `send` node (method call) while walking the AST.
+                # TODO: remove this method if inspecting `send` nodes is unneeded for your cop.
+                # By default, this is aliased to `on_csend` as well to handle method calls
+                # with safe navigation, remove the alias if this is unnecessary.
+                # If kept, ensure your tests cover safe navigation as well!
                 def on_send(node)
                   return unless bad_method?(node)
 
                   add_offense(node)
                 end
+                alias on_csend on_send
               end
             end
           end

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

@@ -112,10 +112,6 @@ module RuboCop
           body = comment_body(comment_line)
           node.source.index(body)
         end
-
-        def relevant_file?(file)
-          file.match?(%r{/cop/.*\.rb\z})
-        end
       end
     end
   end

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

@@ -19,6 +19,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `%<preferred>s`.'
+        RESTRICT_ON_SEND = [:==].freeze
 
         # @!method line_send(node)
         def_node_matcher :line_send, <<~PATTERN
@@ -36,10 +37,8 @@ module RuboCop
         def on_send(node)
           return unless location_line_equality_comparison?(node)
 
-          lhs, _op, rhs = *node
-
-          lhs_receiver = extract_receiver(lhs)
-          rhs_receiver = extract_receiver(rhs)
+          lhs_receiver = extract_receiver(node.receiver)
+          rhs_receiver = extract_receiver(node.first_argument)
           preferred = "same_line?(#{lhs_receiver}, #{rhs_receiver})"
 
           add_offense(node, message: format(MSG, preferred: preferred)) do |corrector|

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module InternalAffairs
-      # Checks for missing `numblock handlers. The blocks with numbered
+      # Checks for missing `numblock` handlers. The blocks with numbered
       # arguments introduced in Ruby 2.7 are parsed with a node type of
       # `numblock` instead of block. Cops that define `block` handlers
       # need to define `numblock` handlers or disable this cope for them.

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Enforces the use of `node.operator_keyword?` instead of `node.and_type? || node.or_type?`.
+      #
+      # @example
+      #   # bad
+      #   node.and_type? || node.or_type?
+      #   node.or_type? || node.and_type?
+      #
+      #   # good
+      #   node.operator_keyword?
+      #
+      class OperatorKeyword < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<prefer>s`.'
+
+        # @!method and_or_type(node)
+        def_node_matcher :and_or_type, <<~PATTERN
+          {
+            (or $(send _node :and_type?) $(send _node :or_type?))
+            (or $(send _node :or_type?) $(send _node :and_type?))
+            (or
+              (or _ $(send _node :and_type?)) $(send _node :or_type?))
+            (or
+              (or _ $(send _node :or_type?)) $(send _node :and_type?))
+          }
+        PATTERN
+
+        def on_or(node)
+          return unless (lhs, rhs = and_or_type(node))
+
+          offense = lhs.receiver.source_range.join(rhs.source_range.end)
+          prefer = "#{lhs.receiver.source}.operator_keyword?"
+
+          add_offense(offense, message: format(MSG, prefer: prefer)) do |corrector|
+            corrector.replace(offense, prefer)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -11,13 +11,9 @@ module RuboCop
       #
       #   # bad
       #   add_offense(node, message: MSG)
-      #   add_offense(node, message: message)
-      #   add_offense(node, message: message(node))
       #
       #   # good
       #   add_offense(node)
-      #   add_offense(node, message: CUSTOM_MSG)
-      #   add_offense(node, message: message(other_node))
       #
       class RedundantMessageArgument < Base
         include RangeHelp
@@ -28,22 +24,21 @@ module RuboCop
 
         # @!method node_type_check(node)
         def_node_matcher :node_type_check, <<~PATTERN
-          (send nil? :add_offense $_node $hash)
+          (send nil? :add_offense _node $hash)
         PATTERN
 
         # @!method redundant_message_argument(node)
         def_node_matcher :redundant_message_argument, <<~PATTERN
           (pair
             (sym :message)
-            ${(const nil? :MSG) (send nil? :message) (send nil? :message _)})
+            $(const nil? :MSG))
         PATTERN
 
-        # @!method message_method_call(node)
-        def_node_matcher :message_method_call, '(send nil? :message $_node)'
-
         def on_send(node)
-          node_type_check(node) do |node_arg, kwargs|
-            find_offending_argument(node_arg, kwargs) do |pair|
+          return unless (kwargs = node_type_check(node))
+
+          kwargs.pairs.each do |pair|
+            redundant_message_argument(pair) do
               add_offense(pair) do |corrector|
                 range = offending_range(pair)
 
@@ -60,16 +55,6 @@ module RuboCop
 
           range_with_surrounding_comma(with_space, :left)
         end
-
-        def find_offending_argument(searched_node, kwargs)
-          kwargs.pairs.each do |pair|
-            redundant_message_argument(pair) do |message_argument|
-              node = message_method_call(message_argument)
-
-              yield pair if !node || node == searched_node
-            end
-          end
-        end
       end
     end
   end

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

@@ -14,6 +14,12 @@ module RuboCop
       #   node.source
       #
       #   # bad
+      #   add_offense(node.source_range)
+      #
+      #   # good
+      #   add_offense(node)
+      #
+      #   # bad
       #   add_offense(node) { |corrector| corrector.replace(node.source_range, prefer) }
       #   add_offense(node) { |corrector| corrector.insert_before(node.source_range, prefer) }
       #   add_offense(node) { |corrector| corrector.insert_before_multi(node.source_range, prefer) }
@@ -34,7 +40,7 @@ module RuboCop
 
         MSG = 'Remove the redundant `source_range`.'
         RESTRICT_ON_SEND = %i[
-          source
+          source add_offense
           replace remove insert_before insert_before_multi insert_after insert_after_multi swap
         ].freeze
 
@@ -42,6 +48,7 @@ module RuboCop
         def_node_matcher :redundant_source_range, <<~PATTERN
           {
             (send $(send _ :source_range) :source)
+            (send nil? :add_offense $(send _ :source_range) ...)
             (send _ {
               :replace :insert_before :insert_before_multi :insert_after :insert_after_multi
             } $(send _ :source_range) _)

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

@@ -50,8 +50,6 @@ module RuboCop
       #   end
       #
       class StyleDetectedApiUse < Base
-        include RangeHelp
-
         MSG_FOR_POSITIVE_WITHOUT_NEGATIVE =
           '`correct_style_detected` method called without ' \
           'calling a negative `*_style_detected` method.'

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

@@ -43,11 +43,6 @@ module RuboCop
             node.ancestors.any? { |ancestor| rspec_expectation_on_msg?(ancestor) }
           end
         end
-
-        # Only process spec files
-        def relevant_file?(file)
-          file.end_with?('_spec.rb')
-        end
       end
     end
   end

data/lib/rubocop/cop/internal_affairs.rb

@@ -17,6 +17,7 @@ require_relative 'internal_affairs/node_matcher_directive'
 require_relative 'internal_affairs/node_type_predicate'
 require_relative 'internal_affairs/numblock_handler'
 require_relative 'internal_affairs/offense_location_keyword'
+require_relative 'internal_affairs/operator_keyword'
 require_relative 'internal_affairs/processed_source_buffer_name'
 require_relative 'internal_affairs/redundant_context_config_parameter'
 require_relative 'internal_affairs/redundant_described_class_as_subject'
@@ -31,3 +32,19 @@ 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

@@ -59,7 +59,11 @@ module RuboCop
           modifiers = body.each_child_node(:send).select(&:bare_access_modifier?)
           end_range = node.loc.end
 
-          modifiers.each { |modifier| check_modifier(modifier, end_range) }
+          modifiers.each do |modifier|
+            next if same_line?(node, modifier)
+
+            check_modifier(modifier, end_range)
+          end
         end
 
         def check_modifier(send_node, end_range)

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

@@ -3,8 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # Here we check if the arguments on a multi-line method
-      # definition are aligned.
+      # Check that the arguments on a multi-line method definition are aligned.
       #
       # @example EnforcedStyle: with_first_argument (default)
       #   # good

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # Here we check if the elements of a multi-line array literal are
+      # Check that the elements of a multi-line array literal are
       # aligned.
       #
       # @example EnforcedStyle: with_first_element (default)

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

@@ -40,7 +40,6 @@ module RuboCop
       #
       class BeginEndAlignment < Base
         include EndKeywordAlignment
-        include RangeHelp
         extend AutoCorrector
 
         MSG = '`end` at %d, %d is not aligned with `%s` at %d, %d.'

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

@@ -127,7 +127,6 @@ module RuboCop
                              start_loc,
                              end_loc,
                              do_source_line_column)
-
           error_source_line_column = if style == :start_of_block
                                        do_source_line_column
                                      else
@@ -189,7 +188,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 while node.op_asgn_type? || node.masgn_type?
+          node = node.lhs while node.op_asgn_type? || node.masgn_type?
           node
         end
 

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

@@ -61,7 +61,7 @@ module RuboCop
         private
 
         def autocorrect(corrector, node)
-          if style == :start_of_line && node.parent && node.parent.send_type?
+          if style == :start_of_line && node.parent&.send_type?
             AlignmentCorrector.align_end(corrector, processed_source, node, node.parent)
           else
             AlignmentCorrector.align_end(corrector, processed_source, node, node)

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

@@ -135,7 +135,7 @@ module RuboCop
 
           parent = next_sibling.parent
 
-          parent&.if_type? && parent&.else?
+          parent&.if_type? && parent.else?
         end
 
         def next_sibling_empty_or_guard_clause?(node)
@@ -200,7 +200,7 @@ module RuboCop
           parent = node.parent
           return false unless parent
 
-          parent.begin_type? && parent.single_line?
+          parent.begin_type? && same_line?(node, node.right_sibling)
         end
 
         # SimpleCov excludes code from the coverage report by wrapping it in `# :nocov:`:

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

@@ -84,9 +84,8 @@ module RuboCop
 
         alias on_numblock 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 expected_empty_lines?(node)
 
           message = message(node)

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

@@ -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
@@ -128,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,9 @@ module RuboCop
         KIND = 'method'
 
         def on_def(node)
-          check(node, node.body)
+          first_line = node.arguments.source_range&.last_line
+
+          check(node, node.body, adjusted_first_line: first_line)
         end
         alias on_defs on_def
 

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

@@ -63,13 +63,21 @@ module RuboCop
       #     }
       #   )
       #
+      # @example AllowedMethods: ['some_method']
+      #
+      #   # good
+      #   some_method(foo, bar,
+      #     baz)
       class FirstMethodArgumentLineBreak < Base
         include FirstElementLineBreak
+        include AllowedMethods
         extend AutoCorrector
 
         MSG = 'Add a line break before the first argument of a multi-line method argument list.'
 
         def on_send(node)
+          return if allowed_method?(node.method_name)
+
           args = node.arguments.dup
 
           # If there is a trailing hash arg without explicit braces, like this:

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

@@ -3,13 +3,12 @@
 module RuboCop
   module Cop
     module Layout
-      # Checks for indentation that doesn't use the specified number
-      # of spaces.
+      # Checks for indentation that doesn't use the specified number of spaces.
+      # The indentation width can be configured using the `Width` setting. The default width is 2.
       #
-      # See also the IndentationConsistency cop which is the companion to this
-      # one.
+      # See also the `Layout/IndentationConsistency` cop which is the companion to this one.
       #
-      # @example
+      # @example Width: 2 (default)
       #   # bad
       #   class A
       #    def test
@@ -59,16 +58,17 @@ module RuboCop
         PATTERN
 
         def on_rescue(node)
-          _begin_node, *_rescue_nodes, else_node = *node
-          check_indentation(node.loc.else, else_node)
+          check_indentation(node.loc.else, node.else_branch)
         end
 
-        def on_ensure(node)
+        def on_resbody(node)
           check_indentation(node.loc.keyword, node.body)
         end
+        alias on_for on_resbody
 
-        alias on_resbody on_ensure
-        alias on_for     on_ensure
+        def on_ensure(node)
+          check_indentation(node.loc.keyword, node.branch)
+        end
 
         def on_kwbegin(node)
           # Check indentation against end keyword but only if it's first on its
@@ -326,8 +326,7 @@ module RuboCop
           if body_node.rescue_type?
             check_rescue?(body_node)
           elsif body_node.ensure_type?
-            block_body, = *body_node
-
+            block_body, = *body_node # rubocop:disable InternalAffairs/NodeDestructuring
             if block_body&.rescue_type?
               check_rescue?(block_body)
             else

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

@@ -49,18 +49,58 @@ module RuboCop
       #   #ruby=2.7.0
       #   #ruby-gemset=myproject
       #
+      # @example AllowRBSInlineAnnotation: false (default)
+      #
+      #   # bad
+      #
+      #   include Enumerable #[Integer]
+      #
+      #   attr_reader :name #: String
+      #   attr_reader :age  #: Integer?
+      #
+      # @example AllowRBSInlineAnnotation: true
+      #
+      #   # good
+      #
+      #   include Enumerable #[Integer]
+      #
+      #   attr_reader :name #: String
+      #   attr_reader :age  #: Integer?
+      #
+      # @example AllowSteepAnnotation: false (default)
+      #
+      #   # bad
+      #   [1, 2, 3].each_with_object([]) do |n, list| #$ Array[Integer]
+      #     list << n
+      #   end
+      #
+      #   name = 'John'      #: String
+      #
+      # @example AllowSteepAnnotation: true
+      #
+      #   # good
+      #
+      #   [1, 2, 3].each_with_object([]) do |n, list| #$ Array[Integer]
+      #     list << n
+      #   end
+      #
+      #   name = 'John'      #: String
+      #
       class LeadingCommentSpace < Base
         include RangeHelp
         extend AutoCorrector
 
         MSG = 'Missing space after `#`.'
 
-        def on_new_investigation
+        def on_new_investigation # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
           processed_source.comments.each do |comment|
             next unless /\A(?!#\+\+|#--)(#+[^#\s=])/.match?(comment.text)
             next if comment.loc.line == 1 && allowed_on_first_line?(comment)
+            next if shebang_continuation?(comment)
             next if doxygen_comment_style?(comment)
             next if gemfile_ruby_comment?(comment)
+            next if rbs_inline_annotation?(comment)
+            next if steep_annotation?(comment)
 
             add_offense(comment) do |corrector|
               expr = comment.source_range
@@ -84,6 +124,20 @@ module RuboCop
           comment.text.start_with?('#!')
         end
 
+        def shebang_continuation?(comment)
+          return false unless shebang?(comment)
+          return true if comment.loc.line == 1
+
+          previous_line_comment = processed_source.comment_at_line(comment.loc.line - 1)
+          return false unless previous_line_comment
+
+          # If the comment is a shebang but not on the first line, check if the previous
+          # line has a shebang comment that wasn't marked as an offense; if so, this comment
+          # continues the shebang and is acceptable.
+          shebang?(previous_line_comment) &&
+            !current_offense_locations.include?(previous_line_comment.source_range)
+        end
+
         def rackup_options?(comment)
           comment.text.start_with?('#\\')
         end
@@ -115,6 +169,22 @@ module RuboCop
         def gemfile_ruby_comment?(comment)
           allow_gemfile_ruby_comment? && ruby_comment_in_gemfile?(comment)
         end
+
+        def allow_rbs_inline_annotation?
+          cop_config['AllowRBSInlineAnnotation']
+        end
+
+        def rbs_inline_annotation?(comment)
+          allow_rbs_inline_annotation? && comment.text.start_with?(/#:|#\[.+\]/)
+        end
+
+        def allow_steep_annotation?
+          cop_config['AllowSteepAnnotation']
+        end
+
+        def steep_annotation?(comment)
+          allow_steep_annotation? && comment.text.start_with?(/#[$:]/)
+        end
       end
     end
   end