rubocop 1.75.8 → 1.81.1

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

@@ -134,6 +134,7 @@ module RuboCop
 
         def check_for_breakable_block(block_node)
           return unless block_node.single_line?
+          return if receiver_contains_heredoc?(block_node)
 
           line_index = block_node.loc.line - 1
           range = breakable_block_range(block_node)
@@ -258,7 +259,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
@@ -321,7 +322,7 @@ module RuboCop
         def extract_heredocs(ast)
           return [] unless ast
 
-          ast.each_node(:str, :dstr, :xstr).select(&:heredoc?).map do |node|
+          ast.each_node(:any_str).select(&:heredoc?).map do |node|
             body = node.location.heredoc_body
             delimiter = node.location.heredoc_end.source.strip
             [body.first_line...body.last_line, delimiter]
@@ -341,6 +342,13 @@ module RuboCop
           heredocs.any? { |range, _delimiter| range.cover?(line_number) }
         end
 
+        def receiver_contains_heredoc?(node)
+          return false unless (receiver = node.receiver)
+          return true if receiver.any_str_type? && receiver.heredoc?
+
+          receiver.each_descendant(:any_str).any?(&:heredoc?)
+        end
+
         def check_directive_line(line, line_index)
           length_without_directive = line_length_without_directive(line)
           return if length_without_directive <= max
@@ -358,11 +366,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)
+
+          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
 
-          register_offense(excess_range(uri_range, line, line_index), line, line_index)
+        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 +
@@ -100,10 +102,12 @@ module RuboCop
             return true if begins_its_line?(assignment_rhs.source_range)
           end
 
-          given_style == :aligned &&
-            (kw_node_with_special_indentation(node) ||
-             assignment_node ||
-             argument_in_method_call(node, :with_or_without_parentheses))
+          return false unless given_style == :aligned
+          return true if kw_node_with_special_indentation(node) || assignment_node
+
+          node = argument_in_method_call(node, :with_or_without_parentheses)
+
+          node.respond_to?(:def_modifier?) && !node.def_modifier?
         end
 
         def message(node, lhs, rhs)

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

@@ -194,6 +194,14 @@ module RuboCop
         def alignment_location(alignment_node)
           if begin_end_alignment_style == 'start_of_line'
             start_line_range(alignment_node)
+          elsif alignment_node.any_block_type?
+            # If the alignment node is a block, the `rescue`/`ensure` keyword should
+            # be aligned to the start of the block. It is possible that the block's
+            # `send_node` spans multiple lines, in which case it should align to the
+            # start of the last line.
+            send_node = alignment_node.send_node
+            range = processed_source.buffer.line_range(send_node.last_line)
+            range.adjust(begin_pos: range.source =~ /\S/)
           else
             alignment_node.source_range
           end

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

@@ -113,7 +113,7 @@ module RuboCop
           return [] unless ast
 
           heredocs = []
-          ast.each_node(:str, :dstr, :xstr) do |node|
+          ast.each_node(:any_str) do |node|
             next unless node.heredoc?
 
             body = node.location.heredoc_body

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
 

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

@@ -118,8 +118,11 @@ module RuboCop
 
         def replacement_args(node)
           algorithm_constant, = algorithm_const(node)
-          algorithm_name = algorithm_name(algorithm_constant)
+          if algorithm_constant.source == 'OpenSSL::Cipher::Cipher'
+            return node.first_argument.source
+          end
 
+          algorithm_name = algorithm_name(algorithm_constant)
           if openssl_class(algorithm_constant) == 'OpenSSL::Cipher'
             build_cipher_arguments(node, algorithm_name, node.arguments.empty?)
           else

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

@@ -6,6 +6,10 @@ module RuboCop
       # Checks for duplicated instance (or singleton) method
       # definitions.
       #
+      # NOTE: Aliasing a method to itself is allowed, as it indicates that
+      # the developer intends to suppress Ruby's method redefinition warnings.
+      # See https://bugs.ruby-lang.org/issues/13574.
+      #
       # @example
       #
       #   # bad
@@ -40,6 +44,18 @@ module RuboCop
       #
       #   alias bar foo
       #
+      #   # good
+      #   alias foo foo
+      #   def foo
+      #     1
+      #   end
+      #
+      #   # good
+      #   alias_method :foo, :foo
+      #   def foo
+      #     1
+      #   end
+      #
       # @example AllCops:ActiveSupportExtensionsEnabled: false (default)
       #
       #   # good
@@ -113,11 +129,13 @@ module RuboCop
 
         # @!method method_alias?(node)
         def_node_matcher :method_alias?, <<~PATTERN
-          (alias (sym $_name) sym)
+          (alias (sym $_name) (sym $_original_name))
         PATTERN
 
         def on_alias(node)
-          return unless (name = method_alias?(node))
+          name, original_name = method_alias?(node)
+          return unless name && original_name
+          return if name == original_name
           return if node.ancestors.any?(&:if_type?)
 
           found_instance_method(node, name)
@@ -125,7 +143,7 @@ module RuboCop
 
         # @!method alias_method?(node)
         def_node_matcher :alias_method?, <<~PATTERN
-          (send nil? :alias_method (sym $_name) _)
+          (send nil? :alias_method (sym $_name) (sym $_original_name))
         PATTERN
 
         # @!method delegate_method?(node)
@@ -140,7 +158,10 @@ module RuboCop
         def_node_matcher :sym_name, '(sym $_name)'
 
         def on_send(node) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-          if (name = alias_method?(node))
+          name, original_name = alias_method?(node)
+
+          if name && original_name
+            return if name == original_name
             return if node.ancestors.any?(&:if_type?)
 
             found_instance_method(node, name)

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

@@ -24,8 +24,6 @@ module RuboCop
 
         MSG_REPEATED_ELEMENT = 'Duplicate element inside regexp character class'
 
-        OCTAL_DIGITS_AFTER_ESCAPE = 2
-
         def on_regexp(node)
           each_repeated_character_class_element_loc(node) do |loc|
             add_offense(loc, message: MSG_REPEATED_ELEMENT) do |corrector|
@@ -40,9 +38,9 @@ module RuboCop
 
             seen = Set.new
             group_expressions(node, expr.expressions) do |group|
-              group_source = group.map(&:to_s).join
+              group_source = group.to_s
 
-              yield source_range(group) if seen.include?(group_source)
+              yield group.expression if seen.include?(group_source)
 
               seen << group_source
             end
@@ -52,40 +50,13 @@ module RuboCop
         private
 
         def group_expressions(node, expressions)
-          # Create a mutable list to simplify state tracking while we iterate.
-          expressions = expressions.to_a
-
-          until expressions.empty?
-            # With we may need to compose a group of multiple expressions.
-            group = [expressions.shift]
-            next if within_interpolation?(node, group.first)
-
-            # With regexp_parser < 2.7 escaped octal sequences may be up to 3
-            # separate expressions ("\\0", "0", "1").
-            pop_octal_digits(group, expressions) if escaped_octal?(group.first.to_s)
-
-            yield(group)
-          end
-        end
-
-        def pop_octal_digits(current_child, expressions)
-          OCTAL_DIGITS_AFTER_ESCAPE.times do
-            next_child = expressions.first
-            break unless octal?(next_child.to_s)
+          expressions.each do |expression|
+            next if within_interpolation?(node, expression)
 
-            current_child << expressions.shift
+            yield(expression)
           end
         end
 
-        def source_range(children)
-          return children.first.expression if children.size == 1
-
-          range_between(
-            children.first.expression.begin_pos,
-            children.last.expression.begin_pos + children.last.to_s.length
-          )
-        end
-
         def skip_expression?(expr)
           expr.type != :set || expr.token == :intersection
         end
@@ -99,14 +70,6 @@ module RuboCop
           interpolation_locs(node).any? { |il| il.overlaps?(parse_tree_child_loc) }
         end
 
-        def escaped_octal?(string)
-          string.length == 2 && string[0] == '\\' && octal?(string[1])
-        end
-
-        def octal?(char)
-          ('0'..'7').cover?(char)
-        end
-
         def interpolation_locs(node)
           @interpolation_locs ||= {}
 

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

@@ -19,7 +19,9 @@ module RuboCop
         MSG = 'Empty interpolation detected.'
 
         def on_interpolation(begin_node)
-          return unless begin_node.children.empty?
+          node_children = begin_node.children.dup
+          node_children.delete_if { |e| e.nil_type? || (e.basic_literal? && e.str_content&.empty?) }
+          return unless node_children.empty?
 
           add_offense(begin_node) { |corrector| corrector.remove(begin_node) }
         end

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

@@ -94,7 +94,7 @@ module RuboCop
           when :float
             true
           when :send
-            check_send(node)
+            float_send?(node)
           when :begin
             float?(node.children.first)
           else
@@ -108,18 +108,18 @@ module RuboCop
           (node.numeric_type? && node.value.zero?) || node.nil_type?
         end
 
-        def check_send(node)
+        def float_send?(node)
           if node.arithmetic_operation?
             float?(node.receiver) || float?(node.first_argument)
           elsif FLOAT_RETURNING_METHODS.include?(node.method_name)
             true
           elsif node.receiver&.float_type?
             FLOAT_INSTANCE_METHODS.include?(node.method_name) ||
-              check_numeric_returning_method(node)
+              numeric_returning_method?(node)
           end
         end
 
-        def check_numeric_returning_method(node)
+        def numeric_returning_method?(node)
           return false unless node.receiver
 
           case node.method_name

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

@@ -11,39 +11,43 @@ module RuboCop
       # @example
       #   # bad
       #   foo.object_id == bar.object_id
+      #   foo.object_id != baz.object_id
       #
       #   # good
       #   foo.equal?(bar)
+      #   !foo.equal?(baz)
       #
       class IdentityComparison < Base
         extend AutoCorrector
 
-        MSG = 'Use `equal?` instead `==` when comparing `object_id`.'
-        RESTRICT_ON_SEND = %i[==].freeze
+        MSG = 'Use `%<bang>sequal?` instead of `%<comparison_method>s` when comparing `object_id`.'
+        RESTRICT_ON_SEND = %i[== !=].freeze
+
+        # @!method object_id_comparison(node)
+        def_node_matcher :object_id_comparison, <<~PATTERN
+          (send
+            (send
+              _lhs_receiver :object_id) ${:== :!=}
+            (send
+              _rhs_receiver :object_id))
+        PATTERN
 
         def on_send(node)
-          return unless compare_between_object_id_by_double_equal?(node)
+          return unless (comparison_method = object_id_comparison(node))
 
-          add_offense(node) do |corrector|
+          bang = comparison_method == :== ? '' : '!'
+          add_offense(node,
+                      message: format(MSG, comparison_method: comparison_method,
+                                           bang: bang)) do |corrector|
             receiver = node.receiver.receiver
             argument = node.first_argument.receiver
             return unless receiver && argument
 
-            replacement = "#{receiver.source}.equal?(#{argument.source})"
+            replacement = "#{bang}#{receiver.source}.equal?(#{argument.source})"
 
             corrector.replace(node, replacement)
           end
         end
-
-        private
-
-        def compare_between_object_id_by_double_equal?(node)
-          object_id_method?(node.receiver) && object_id_method?(node.first_argument)
-        end
-
-        def object_id_method?(node)
-          node.send_type? && node.method?(:object_id)
-        end
       end
     end
   end