rubocop 1.41.1 → 1.57.1

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

@@ -59,12 +59,12 @@ module RuboCop
         def method_directives(node)
           comments = processed_source.ast_with_comments[node]
 
-          comments.map do |comment|
+          comments.filter_map do |comment|
             match = comment.text.match(REGEXP)
             next unless match
 
             { node: comment, method_name: match[:method_name], args: match[:args] }
-          end.compact
+          end
         end
 
         def too_many_directives(node)
@@ -99,7 +99,7 @@ module RuboCop
           # If the pattern matcher uses arguments (`%1`, `%2`, etc.), include them in the directive
           arguments = pattern_arguments(node.arguments[1].source)
 
-          range = range_with_surrounding_space(node.loc.expression, side: :left, newlines: false)
+          range = range_with_surrounding_space(node.source_range, side: :left, newlines: false)
           indentation = range.source.match(/^\s*/)[0]
           directive = "#{indentation}# @!method #{actual_name}(#{arguments.join(', ')})\n"
           directive = "\n#{directive}" if add_newline?(node)
@@ -117,11 +117,11 @@ module RuboCop
         def add_newline?(node)
           # Determine if a blank line should be inserted before the new directive
           # in order to spread out pattern matchers
-          return if node.sibling_index&.zero?
-          return unless node.parent
+          return false if node.sibling_index&.zero?
+          return false unless node.parent
 
           prev_sibling = node.parent.child_nodes[node.sibling_index - 1]
-          return unless prev_sibling && pattern_matcher?(prev_sibling)
+          return false unless prev_sibling && pattern_matcher?(prev_sibling)
 
           node.loc.line == last_line(prev_sibling) + 1
         end

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

@@ -30,7 +30,7 @@ module RuboCop
 
             message = format(MSG, type: node_type)
             add_offense(node, message: message) do |corrector|
-              range = node.loc.expression.with(begin_pos: receiver.loc.expression.end_pos + 1)
+              range = node.source_range.with(begin_pos: receiver.source_range.end_pos + 1)
               corrector.replace(range, "#{node_type}_type?")
             end
           end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Enforces the use of `processed_source.file_path` instead of `processed_source.buffer.name`.
+      #
+      # @example
+      #
+      #   # bad
+      #   processed_source.buffer.name
+      #
+      #   # good
+      #   processed_source.file_path
+      #
+      class ProcessedSourceBufferName < Base
+        extend AutoCorrector
+
+        MSG = 'Use `file_path` instead.'
+
+        RESTRICT_ON_SEND = %i[name].freeze
+
+        # @!method processed_source_buffer_name?(node)
+        def_node_matcher :processed_source_buffer_name?, <<~PATTERN
+          (send
+            (send
+              {(lvar :processed_source) (send nil? :processed_source)} :buffer) :name)
+        PATTERN
+
+        def on_send(node)
+          return unless processed_source_buffer_name?(node)
+
+          offense_range = node.children.first.loc.selector.begin.join(node.source_range.end)
+
+          add_offense(offense_range) do |corrector|
+            corrector.replace(offense_range, 'file_path')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -31,9 +31,17 @@ module RuboCop
             (send nil? :let
               (sym :config))
             (args)
-            (send
-              (const
-                (const nil? :RuboCop) :Config) :new))
+            {
+              (send
+                (const
+                  (const nil? :RuboCop) :Config) :new)
+              (send
+                (const
+                  (const nil? :RuboCop) :Config) :new
+                    (hash (pair (send (send (send nil? :described_class) :badge) :to_s)
+                      (send nil? :cop_config))))
+            }
+          )
         PATTERN
 
         def on_block(node)

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

@@ -43,7 +43,7 @@ module RuboCop
         private
 
         def offending_range(node)
-          with_space = range_with_surrounding_space(node.loc.expression)
+          with_space = range_with_surrounding_space(node.source_range)
 
           range_with_surrounding_comma(with_space, :left)
         end

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

@@ -56,7 +56,7 @@ module RuboCop
         private
 
         def offending_range(node)
-          with_space = range_with_surrounding_space(node.loc.expression)
+          with_space = range_with_surrounding_space(node.source_range)
 
           range_with_surrounding_comma(with_space, :left)
         end

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

@@ -14,6 +14,12 @@ module RuboCop
       #   node.method_name
       #
       #   # bad
+      #   node.send_node.method?(:method_name)
+      #
+      #   # good
+      #   node.method?(:method_name)
+      #
+      #   # bad
       #   node.send_node.receiver
       #
       #   # good
@@ -24,11 +30,14 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Remove the redundant `send_node`.'
-        RESTRICT_ON_SEND = %i[method_name receiver].freeze
+        RESTRICT_ON_SEND = %i[method_name method? receiver].freeze
 
         # @!method dispatch_method(node)
         def_node_matcher :dispatch_method, <<~PATTERN
-          (send $(send _ :send_node) _)
+          {
+            (send $(send _ :send_node) {:method_name :receiver})
+            (send $(send _ :send_node) :method? _)
+          }
         PATTERN
 
         def on_send(node)

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks for redundant `source_range`.
+      #
+      # @example
+      #
+      #   # bad
+      #   node.source_range.source
+      #
+      #   # good
+      #   node.source
+      #
+      #   # 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) }
+      #   add_offense(node) { |corrector| corrector.insert_after(node.source_range, prefer) }
+      #   add_offense(node) { |corrector| corrector.insert_after_multi(node.source_range, prefer) }
+      #   add_offense(node) { |corrector| corrector.swap(node.source_range, before, after) }
+      #
+      #   # good
+      #   add_offense(node) { |corrector| corrector.replace(node, prefer) }
+      #   add_offense(node) { |corrector| corrector.insert_before(node, prefer) }
+      #   add_offense(node) { |corrector| corrector.insert_before_multi(node, prefer) }
+      #   add_offense(node) { |corrector| corrector.insert_after(node, prefer) }
+      #   add_offense(node) { |corrector| corrector.insert_after_multi(node, prefer) }
+      #   add_offense(node) { |corrector| corrector.swap(node, before, after) }
+      #
+      class RedundantSourceRange < Base
+        extend AutoCorrector
+
+        MSG = 'Remove the redundant `source_range`.'
+        RESTRICT_ON_SEND = %i[
+          source
+          replace remove insert_before insert_before_multi insert_after insert_after_multi swap
+        ].freeze
+
+        # @!method redundant_source_range(node)
+        def_node_matcher :redundant_source_range, <<~PATTERN
+          {
+            (send $(send _ :source_range) :source)
+            (send _ {
+              :replace :insert_before :insert_before_multi :insert_after :insert_after_multi
+            } $(send _ :source_range) _)
+            (send _ :remove $(send _ :source_range))
+            (send _ :swap $(send _ :source_range) _ _)
+          }
+        PATTERN
+
+        def on_send(node)
+          return unless (source_range = redundant_source_range(node))
+          return if source_range.receiver.send_type? && source_range.receiver.method?(:buffer)
+
+          selector = source_range.loc.selector
+
+          add_offense(selector) do |corrector|
+            corrector.remove(source_range.loc.dot.join(selector))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -27,6 +27,8 @@ module RuboCop
         PATTERN
 
         def on_new_investigation
+          return if processed_source.blank?
+
           assertions_using_described_class_msg.each { |node| add_offense(node) }
         end
 

data/lib/rubocop/cop/internal_affairs.rb

@@ -7,6 +7,7 @@ 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_expression'
 require_relative 'internal_affairs/location_line_equality_comparison'
 require_relative 'internal_affairs/method_name_end_with'
 require_relative 'internal_affairs/method_name_equal'
@@ -15,12 +16,14 @@ 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/processed_source_buffer_name'
 require_relative 'internal_affairs/redundant_context_config_parameter'
 require_relative 'internal_affairs/redundant_described_class_as_subject'
 require_relative 'internal_affairs/redundant_let_rubocop_config_new'
 require_relative 'internal_affairs/redundant_location_argument'
 require_relative 'internal_affairs/redundant_message_argument'
 require_relative 'internal_affairs/redundant_method_dispatch_node'
+require_relative 'internal_affairs/redundant_source_range'
 require_relative 'internal_affairs/single_line_comparison'
 require_relative 'internal_affairs/style_detected_api_use'
 require_relative 'internal_affairs/undefined_config'

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

@@ -76,7 +76,7 @@ module RuboCop
         end
 
         def target_method_lineno(node)
-          node.loc.line
+          node.bracketed? ? node.loc.line : node.parent.loc.line
         end
       end
     end

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

@@ -36,17 +36,19 @@ module RuboCop
           # If the end is on its own line, there is no offense
           return if begins_its_line?(node.loc.end)
 
-          register_offense(node)
+          offense_range = offense_range(node)
+          return if offense_range.source.lstrip.start_with?(';')
+
+          register_offense(node, offense_range)
         end
 
         alias on_numblock on_block
 
         private
 
-        def register_offense(node)
+        def register_offense(node, offense_range)
           add_offense(node.loc.end, message: message(node)) do |corrector|
-            offense_range = offense_range(node)
-            replacement = "\n#{offense_range.source.strip}"
+            replacement = "\n#{offense_range.source.lstrip}"
 
             if (heredoc = last_heredoc_argument(node.body))
               corrector.remove(offense_range)
@@ -72,17 +74,7 @@ module RuboCop
         end
 
         def offense_range(node)
-          Parser::Source::Range.new(
-            node.loc.expression.source_buffer,
-            node.children.compact.last.loc.expression.end_pos,
-            end_of_method_chain(node).loc.expression.end_pos
-          )
-        end
-
-        def end_of_method_chain(node)
-          return node unless node.parent&.call_type?
-
-          end_of_method_chain(node.parent)
+          node.children.compact.last.source_range.end.join(node.loc.end)
         end
       end
     end

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

@@ -68,6 +68,13 @@ module RuboCop
       #        - extend
       # ----
       #
+      # @safety
+      #   Autocorrection is unsafe because class methods and module inclusion
+      #   can behave differently, based on which methods or constants have
+      #   already been defined.
+      #
+      #   Constants will only be moved when they are assigned with literals.
+      #
       # @example
       #   # bad
       #   # Expect extend be before constant
@@ -134,22 +141,18 @@ module RuboCop
       #
       class ClassStructure < Base
         include VisibilityHelp
+        include CommentsHelp
         extend AutoCorrector
 
         HUMANIZED_NODE_TYPE = {
           casgn: :constants,
-          defs: :class_methods,
+          defs: :public_class_methods,
           def: :public_methods,
           sclass: :class_singleton
         }.freeze
 
         MSG = '`%<category>s` is supposed to appear before `%<previous>s`.'
 
-        # @!method dynamic_constant?(node)
-        def_node_matcher :dynamic_constant?, <<~PATTERN
-          (casgn nil? _ (send ...))
-        PATTERN
-
         # Validates code style on class declaration.
         # Add offense when find a node out of expected order.
         def on_class(class_node)
@@ -163,12 +166,13 @@ module RuboCop
             previous = index
           end
         end
+        alias on_sclass on_class
 
         private
 
         # Autocorrect by swapping between two nodes autocorrecting them
         def autocorrect(corrector, node)
-          previous = node.left_siblings.find do |sibling|
+          previous = node.left_siblings.reverse.find do |sibling|
             !ignore_for_autocorrect?(node, sibling)
           end
           return unless previous
@@ -221,7 +225,7 @@ module RuboCop
         def walk_over_nested_class_definition(class_node)
           class_elements(class_node).each do |node|
             classification = classify(node)
-            next if ignore?(classification)
+            next if ignore?(node, classification)
 
             yield node, classification
           end
@@ -239,17 +243,20 @@ module RuboCop
           end
         end
 
-        def ignore?(classification)
+        def ignore?(node, classification)
           classification.nil? ||
             classification.to_s.end_with?('=') ||
-            expected_order.index(classification).nil?
+            expected_order.index(classification).nil? ||
+            private_constant?(node)
         end
 
         def ignore_for_autocorrect?(node, sibling)
           classification = classify(node)
           sibling_class = classify(sibling)
 
-          ignore?(sibling_class) || classification == sibling_class || dynamic_constant?(node)
+          ignore?(sibling, sibling_class) ||
+            classification == sibling_class ||
+            dynamic_constant?(node)
         end
 
         def humanize_node(node)
@@ -261,26 +268,37 @@ module RuboCop
           HUMANIZED_NODE_TYPE[node.type] || node.type
         end
 
-        def source_range_with_comment(node)
-          begin_pos, end_pos =
-            if (node.def_type? && !node.method?(:initialize)) ||
-               (node.send_type? && node.def_modifier?)
-              start_node = find_visibility_start(node) || node
-              end_node = find_visibility_end(node) || node
-              [begin_pos_with_comment(start_node),
-               end_position_for(end_node) + 1]
-            else
-              [begin_pos_with_comment(node), end_position_for(node)]
-            end
+        def dynamic_constant?(node)
+          return false unless node.casgn_type? && node.namespace.nil?
 
-          Parser::Source::Range.new(buffer, begin_pos, end_pos)
+          expression = node.expression
+          expression.send_type? &&
+            !(expression.method?(:freeze) && expression.receiver&.recursive_basic_literal?)
+        end
+
+        def private_constant?(node)
+          return false unless node.casgn_type? && node.namespace.nil?
+          return false unless (parent = node.parent)
+
+          parent.each_child_node(:send) do |child_node|
+            return true if marked_as_private_constant?(child_node, node.name)
+          end
+          false
+        end
+
+        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 }
         end
 
         def end_position_for(node)
-          heredoc = find_heredoc(node)
-          return heredoc.location.heredoc_end.end_pos + 1 if heredoc
+          if node.casgn_type?
+            heredoc = find_heredoc(node)
+            return heredoc.location.heredoc_end.end_pos + 1 if heredoc
+          end
 
-          end_line = buffer.line_for_position(node.loc.expression.end_pos)
+          end_line = buffer.line_for_position(node.source_range.end_pos)
           buffer.line_range(end_line).end_pos
         end
 

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

@@ -3,7 +3,6 @@
 module RuboCop
   module Cop
     module Layout
-      #
       # Checks the indentation of here document closings.
       #
       # @example
@@ -73,7 +72,7 @@ module RuboCop
         end
 
         def argument_indentation_correct?(node)
-          return unless node.argument? || node.chained?
+          return false unless node.argument? || node.chained?
 
           opening_indentation(
             find_node_used_heredoc_argument(node.parent)
@@ -85,7 +84,7 @@ module RuboCop
         end
 
         def heredoc_opening(node)
-          node.loc.expression.source_line
+          node.source_range.source_line
         end
 
         def heredoc_closing(node)

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

@@ -144,7 +144,7 @@ module RuboCop
         def expected_column(left_paren, elements)
           if line_break_after_left_paren?(left_paren, elements)
             source_indent = processed_source.line_indentation(first_argument_line(elements))
-            new_indent    = source_indent - indentation_width
+            new_indent    = source_indent - configured_indentation_width
 
             new_indent.negative? ? 0 : new_indent
           elsif all_elements_aligned?(elements)
@@ -157,7 +157,7 @@ module RuboCop
         def all_elements_aligned?(elements)
           elements.flat_map do |e|
             if e.hash_type?
-              e.each_pair.map { |pair| pair.loc.column }
+              e.each_child_node.map { |child| child.loc.column }
             else
               e.loc.column
             end
@@ -184,10 +184,6 @@ module RuboCop
           end
         end
 
-        def indentation_width
-          @config.for_cop('Layout/IndentationWidth')['Width'] || 2
-        end
-
         def line_break_after_left_paren?(left_paren, elements)
           elements.first && elements.first.loc.line > left_paren.line
         end

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

@@ -154,7 +154,9 @@ module RuboCop
         end
 
         def less_indented?(line)
-          /^\s*(end\b|[)}\]])/.match?(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))
         end
 
         def two_alternatives?(line)

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

@@ -32,7 +32,7 @@ module RuboCop
         end
 
         def on_send(node)
-          return unless node.dot? || ampersand_dot?(node)
+          return unless node.dot? || node.safe_navigation?
 
           return correct_style_detected if proper_dot_position?(node)
 
@@ -133,10 +133,6 @@ module RuboCop
           # l.(1) has no selector, so we use the opening parenthesis instead
           node.loc.selector || node.loc.begin
         end
-
-        def ampersand_dot?(node)
-          node.loc.respond_to?(:dot) && node.loc.dot && node.loc.dot.is?('&.')
-        end
       end
     end
   end

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

@@ -97,9 +97,9 @@ module RuboCop
         def autocorrect(corrector, node)
           previous_token = previous_token(node)
           range = if previous_token && same_line?(node, previous_token)
-                    range_with_surrounding_space(node.loc.expression, newlines: false)
+                    range_with_surrounding_space(node.source_range, newlines: false)
                   else
-                    range_by_whole_lines(node.loc.expression, include_final_newline: true)
+                    range_by_whole_lines(node.source_range, include_final_newline: true)
                   end
 
           corrector.remove(range)
@@ -137,7 +137,7 @@ module RuboCop
         end
 
         def current_token(comment)
-          processed_source.find_token { |token| token.pos == comment.loc.expression }
+          processed_source.tokens.find { |token| token.pos == comment.source_range }
         end
 
         def previous_token(node)