rubocop 1.75.8 → 1.80.1

data/lib/rubocop/cop/correctors/alignment_corrector.rb

@@ -29,10 +29,13 @@ module RuboCop
         def align_end(corrector, processed_source, node, align_to)
           @processed_source = processed_source
           whitespace = whitespace_range(node)
-          return false unless whitespace.source.strip.empty?
-
           column = alignment_column(align_to)
-          corrector.replace(whitespace, ' ' * column)
+
+          if whitespace.source.strip.empty?
+            corrector.replace(whitespace, ' ' * column)
+          else
+            corrector.insert_after(whitespace, "\n#{' ' * column}")
+          end
         end
 
         private

data/lib/rubocop/cop/correctors/for_to_each_corrector.rb

@@ -6,7 +6,7 @@ module RuboCop
     class ForToEachCorrector
       extend NodePattern::Macros
 
-      CORRECTION = '%<collection>s.each do |%<argument>s|'
+      CORRECTION = '%<collection>s%<dot>seach do |%<argument>s|'
 
       def initialize(for_node)
         @for_node        = for_node
@@ -25,7 +25,12 @@ module RuboCop
       attr_reader :for_node, :variable_node, :collection_node
 
       def correction
-        format(CORRECTION, collection: collection_source, argument: variable_node.source)
+        format(
+          CORRECTION,
+          collection: collection_source,
+          dot: collection_node.csend_type? ? '&.' : '.',
+          argument: variable_node.source
+        )
       end
 
       def collection_source

data/lib/rubocop/cop/correctors/parentheses_corrector.rb

@@ -10,8 +10,11 @@ module RuboCop
         COMMA_REGEXP = /(?<=\))\s*,/.freeze
 
         def correct(corrector, node)
-          corrector.remove(node.loc.begin)
-          corrector.remove(node.loc.end)
+          buffer = node.source_range.source_buffer
+          corrector.remove(range_with_surrounding_space(range: node.loc.begin, buffer: buffer,
+                                                        side: :right, whitespace: true))
+          corrector.remove(range_with_surrounding_space(range: node.loc.end, buffer: buffer,
+                                                        side: :left))
           handle_orphaned_comma(corrector, node)
 
           return unless ternary_condition?(node) && next_char_is_question_mark?(node)

data/lib/rubocop/cop/gemspec/attribute_assignment.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gemspec
+      # Use consistent style for Gemspec attributes assignment.
+      #
+      # @example
+      #
+      #   # bad
+      #   # This example uses two styles for assignment of metadata attribute.
+      #   Gem::Specification.new do |spec|
+      #     spec.metadata = { 'key' => 'value' }
+      #     spec.metadata['another-key'] = 'another-value'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.metadata['key'] = 'value'
+      #     spec.metadata['another-key'] = 'another-value'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.metadata = { 'key' => 'value', 'another-key' => 'another-value' }
+      #   end
+      #
+      #   # bad
+      #   # This example uses two styles for assignment of authors attribute.
+      #   Gem::Specification.new do |spec|
+      #     spec.authors = %w[author-0 author-1]
+      #     spec.authors[2] = 'author-2'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.authors = %w[author-0 author-1 author-2]
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.authors[0] = 'author-0'
+      #     spec.authors[1] = 'author-1'
+      #     spec.authors[2] = 'author-2'
+      #   end
+      #
+      #   # good
+      #   # This example uses consistent assignment per attribute,
+      #   # even though two different styles are used overall.
+      #   Gem::Specification.new do |spec|
+      #     spec.metadata = { 'key' => 'value' }
+      #     spec.authors[0] = 'author-0'
+      #     spec.authors[1] = 'author-1'
+      #     spec.authors[2] = 'author-2'
+      #   end
+      #
+      class AttributeAssignment < Base
+        include GemspecHelp
+
+        MSG = 'Use consistent style for Gemspec attributes assignment.'
+
+        def on_new_investigation
+          return if processed_source.blank?
+
+          assignments = source_assignments(processed_source.ast)
+          indexed_assignments = source_indexed_assignments(processed_source.ast)
+
+          assignments.keys.intersection(indexed_assignments.keys).each do |attribute|
+            indexed_assignments[attribute].each do |node|
+              add_offense(node)
+            end
+          end
+        end
+
+        private
+
+        def source_assignments(ast)
+          assignment_method_declarations(ast)
+            .select(&:assignment_method?)
+            .group_by(&:method_name)
+            .transform_keys { |method_name| method_name.to_s.delete_suffix('=').to_sym }
+        end
+
+        def source_indexed_assignments(ast)
+          indexed_assignment_method_declarations(ast)
+            .group_by { |node| node.children.first.method_name }
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/gemspec/duplicated_assignment.rb

@@ -54,22 +54,6 @@ module RuboCop
         MSG = '`%<assignment>s` method calls already given on line ' \
               '%<line_of_first_occurrence>d of the gemspec.'
 
-        # @!method assignment_method_declarations(node)
-        def_node_search :assignment_method_declarations, <<~PATTERN
-          (send
-            (lvar #match_block_variable_name?) _ ...)
-        PATTERN
-
-        # @!method indexed_assignment_method_declarations(node)
-        def_node_search :indexed_assignment_method_declarations, <<~PATTERN
-          (send
-            (send (lvar #match_block_variable_name?) _)
-            :[]=
-            literal?
-            _
-          )
-        PATTERN
-
         def on_new_investigation
           return if processed_source.blank?
 
@@ -96,12 +80,6 @@ module RuboCop
           end
         end
 
-        def match_block_variable_name?(receiver_name)
-          gem_specification(processed_source.ast) do |block_variable_name|
-            return block_variable_name == receiver_name
-          end
-        end
-
         def duplicated_assignment_method_nodes
           assignment_method_declarations(processed_source.ast)
             .select(&:assignment_method?)

data/lib/rubocop/cop/gemspec/ordered_dependencies.rb

@@ -71,7 +71,7 @@ module RuboCop
 
           dependency_declarations(processed_source.ast)
             .each_cons(2) do |previous, current|
-            next unless consecutive_lines(previous, current)
+            next unless consecutive_lines?(previous, current)
             next unless case_insensitive_out_of_order?(gem_name(current), gem_name(previous))
             next unless get_dependency_name(previous) == get_dependency_name(current)
 

data/lib/rubocop/cop/gemspec/require_mfa.rb

@@ -74,6 +74,14 @@ module RuboCop
           }
         PATTERN
 
+        # @!method metadata_assignment(node)
+        def_node_search :metadata_assignment, <<~PATTERN
+          `{
+            (send _ :metadata= _)
+            (send (send _ :metadata) :[]= (str _) _)
+          }
+        PATTERN
+
         # @!method rubygems_mfa_required(node)
         def_node_search :rubygems_mfa_required, <<~PATTERN
           (pair (str "rubygems_mfa_required") $_)
@@ -131,9 +139,15 @@ module RuboCop
         end
 
         def insert_mfa_required(corrector, node, block_var)
-          corrector.insert_before(node.loc.end, <<~RUBY)
+          require_mfa_directive = <<~RUBY.strip
             #{block_var}.metadata['rubygems_mfa_required'] = 'true'
           RUBY
+
+          if (last_assignment = metadata_assignment(processed_source.ast).to_a.last)
+            corrector.insert_after(last_assignment, "\n#{require_mfa_directive}")
+          else
+            corrector.insert_before(node.loc.end, "#{require_mfa_directive}\n")
+          end
         end
 
         def change_value(corrector, value)

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

@@ -46,7 +46,7 @@ module RuboCop
           /\A(does not|doesn't) (register|find|flag|report)/ => 'registers',
           /\A(does not|doesn't) add (a|an|any )?offense/ => 'registers an offense',
           /\Aregisters no offense/ => 'registers an offense',
-          /\A(accepts|register)\b/ => 'registers'
+          /\A(accepts|allows|register)\b/ => 'registers'
         }.freeze
 
         EXPECT_NO_CORRECTIONS_DESCRIPTION_MAPPING = {

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

@@ -110,8 +110,8 @@ module RuboCop
         def directive_offense_type(directive, actual_name)
           return :missing_directive unless directive
 
-          return :wrong_scope if wrong_scope(directive, actual_name)
-          return :no_scope if no_scope(directive, actual_name)
+          return :wrong_scope if wrong_scope?(directive, actual_name)
+          return :no_scope if no_scope?(directive, actual_name)
 
           # The method directive being prefixed by 'self.' is always an offense.
           # The matched method_name does not contain the receiver but the
@@ -121,11 +121,11 @@ module RuboCop
           end
         end
 
-        def wrong_scope(directive, actual_name)
+        def wrong_scope?(directive, actual_name)
           !actual_name.start_with?('self.') && directive[:has_scope_directive]
         end
 
-        def no_scope(directive, actual_name)
+        def no_scope?(directive, actual_name)
           actual_name.start_with?('self.') && !directive[:has_scope_directive]
         end
 

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

@@ -29,6 +29,7 @@ module RuboCop
         NODE_GROUPS = {
           any_block: %i[block numblock itblock],
           any_def: %i[def defs],
+          any_match_pattern: %i[match_pattern match_pattern_p],
           argument: %i[arg optarg restarg kwarg kwoptarg kwrestarg blockarg forward_arg shadowarg],
           boolean: %i[true false],
           call: %i[send csend],

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

@@ -66,8 +66,9 @@ module RuboCop
         end
 
         def autocorrect_to_explicit_predicate(corrector, node, group_name)
-          corrector.replace(node.selector, "#{group_name}_type?")
-          corrector.remove(arguments_range(node))
+          range = node.loc.selector.begin.join(node.source_range.end)
+
+          corrector.replace(range, "#{group_name}_type?")
         end
 
         def autocorrect_keep_method(corrector, symbol_args, group_name, group_types)

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/layout/closing_parenthesis_indentation.rb

@@ -161,7 +161,7 @@ module RuboCop
             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/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

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

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_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/line_length.rb

@@ -258,7 +258,7 @@ module RuboCop
           if ignore_cop_directives? && directive_on_source_line?(line_index)
             return check_directive_line(line, line_index)
           end
-          return check_uri_line(line, line_index) if allow_uri?
+          return check_line_for_exemptions(line, line_index) if allow_uri? || allow_qualified_name?
 
           register_offense(excess_range(nil, line, line_index), line, line_index)
         end
@@ -358,11 +358,32 @@ module RuboCop
           )
         end
 
-        def check_uri_line(line, line_index)
-          uri_range = find_excessive_uri_range(line)
-          return if uri_range && allowed_uri_position?(line, uri_range)
+        def check_line_for_exemptions(line, line_index)
+          uri_range            = range_if_applicable(line, :uri)
+          qualified_name_range = range_if_applicable(line, :qualified_name)
 
-          register_offense(excess_range(uri_range, line, line_index), line, line_index)
+          return if allowed_combination?(line, uri_range, qualified_name_range)
+
+          range = uri_range || qualified_name_range
+          register_offense(excess_range(range, line, line_index), line, line_index)
+        end
+
+        def range_if_applicable(line, type)
+          return unless type == :uri ? allow_uri? : allow_qualified_name?
+
+          find_excessive_range(line, type)
+        end
+
+        def allowed_combination?(line, uri_range, qualified_name_range)
+          if uri_range && qualified_name_range
+            allowed_position?(line, uri_range) && allowed_position?(line, qualified_name_range)
+          elsif uri_range
+            allowed_position?(line, uri_range)
+          elsif qualified_name_range
+            allowed_position?(line, qualified_name_range)
+          else
+            false
+          end
         end
 
         def breakable_dstr?(node)

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

@@ -10,6 +10,8 @@ module RuboCop
       # condition, an explicit `return` statement, etc. In other contexts, the second operand should
       # be indented regardless of enforced style.
       #
+      # In both styles, operators should be aligned when an assignment begins on the next line.
+      #
       # @example EnforcedStyle: aligned (default)
       #   # bad
       #   if a +

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

@@ -16,6 +16,8 @@ module RuboCop
       #
       #   something = 123if test
       #
+      #   return(foo + bar)
+      #
       #   # good
       #   something 'test' do |x|
       #   end
@@ -24,6 +26,9 @@ module RuboCop
       #   end
       #
       #   something = 123 if test
+      #
+      #   return (foo + bar)
+      #
       class SpaceAroundKeyword < Base
         extend AutoCorrector
 
@@ -33,7 +38,7 @@ module RuboCop
         DO = 'do'
         SAFE_NAVIGATION = '&.'
         NAMESPACE_OPERATOR = '::'
-        ACCEPT_LEFT_PAREN = %w[break defined? next not rescue return super yield].freeze
+        ACCEPT_LEFT_PAREN = %w[break defined? next not rescue super yield].freeze
         ACCEPT_LEFT_SQUARE_BRACKET = %w[super yield].freeze
         ACCEPT_NAMESPACE_OPERATOR = 'super'
         RESTRICT_ON_SEND = %i[!].freeze

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

@@ -151,6 +151,14 @@ module RuboCop
           check_operator(:match_pattern, node.loc.operator, node)
         end
 
+        def on_match_alt(node)
+          check_operator(:match_alt, node.loc.operator, node)
+        end
+
+        def on_match_as(node)
+          check_operator(:match_as, node.loc.operator, node)
+        end
+
         alias on_or       on_binary
         alias on_and      on_binary
         alias on_lvasgn   on_assignment

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

@@ -22,10 +22,11 @@ module RuboCop
         RESTRICT_ON_SEND = %i[[] []=].freeze
 
         def on_send(node)
+          return if node.loc.dot
+
           receiver_end_pos = node.receiver.source_range.end_pos
           selector_begin_pos = node.loc.selector.begin_pos
           return if receiver_end_pos >= selector_begin_pos
-          return if dot_before_brackets?(node, receiver_end_pos, selector_begin_pos)
 
           range = range_between(receiver_end_pos, selector_begin_pos)
 
@@ -33,14 +34,6 @@ module RuboCop
             corrector.remove(range)
           end
         end
-
-        private
-
-        def dot_before_brackets?(node, receiver_end_pos, selector_begin_pos)
-          return false unless node.loc.respond_to?(:dot) && (dot = node.loc.dot)
-
-          dot.begin_pos == receiver_end_pos && dot.end_pos == selector_begin_pos
-        end
       end
     end
   end

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

@@ -86,6 +86,7 @@ module RuboCop
         def on_array(node)
           return if node.array_type? && !node.square_brackets?
 
+          node = find_node_with_brackets(node)
           tokens, left, right = array_brackets(node)
           return unless left && right
 
@@ -102,6 +103,10 @@ module RuboCop
 
         private
 
+        def find_node_with_brackets(node)
+          node.ancestors.find(&:const_pattern_type?) || node
+        end
+
         def autocorrect(corrector, node)
           tokens, left, right = array_brackets(node)
 
@@ -119,7 +124,7 @@ module RuboCop
         def array_brackets(node)
           tokens = processed_source.tokens_within(node)
 
-          left = tokens.find(&:left_array_bracket?)
+          left = tokens.find(&:left_bracket?)
           right = tokens.reverse_each.find(&:right_bracket?)
 
           [tokens, left, right]
@@ -192,7 +197,7 @@ module RuboCop
           if side == :right
             processed_source.tokens_within(node)[i].right_bracket?
           else
-            processed_source.tokens_within(node)[i].left_array_bracket?
+            processed_source.tokens_within(node)[i].left_bracket?
           end
         end
 

data/lib/rubocop/cop/lint/ambiguous_range.rb

@@ -27,7 +27,9 @@ module RuboCop
       # @example
       #   # bad
       #   x || 1..2
+      #   x - 1..2
       #   (x || 1..2)
+      #   x || 1..y || 2
       #   1..2.to_a
       #
       #   # good, unambiguous
@@ -41,6 +43,7 @@ module RuboCop
       #
       #   # good, ambiguity removed
       #   x || (1..2)
+      #   (x - 1)..2
       #   (x || 1)..2
       #   (x || 1)..(y || 2)
       #   (1..2).to_a
@@ -96,6 +99,8 @@ module RuboCop
           # to avoid the ambiguity of `1..2.to_a`.
           return false if node.receiver&.basic_literal?
 
+          return false if node.operator_method? && !node.method?(:[])
+
           require_parentheses_for_method_chain? || node.receiver.nil?
         end