rubocop 1.75.8 → 1.82.1

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/else_layout.rb

@@ -38,6 +38,24 @@ module RuboCop
       #   elsif do_this
       #     do_that
       #   end
+      #
+      #   # bad
+      #
+      #   # For single-line conditionals using `then` the layout is disallowed
+      #   # when the `else` body is multiline because it is treated as a lint offense.
+      #   if something then on_the_same_line_as_then
+      #   else first_line
+      #     second_line
+      #   end
+      #
+      #   # good
+      #
+      #   # For single-line conditional using `then` the layout is allowed
+      #   # when `else` body is a single-line because it is treated as intentional.
+      #
+      #   if something then on_the_same_line_as_then
+      #   else single_line
+      #   end
       class ElseLayout < Base
         include Alignment
         include RangeHelp
@@ -47,6 +65,7 @@ module RuboCop
 
         def on_if(node)
           return if node.ternary?
+          return if node.then? && !node.else_branch&.begin_type?
 
           # If the if is on a single line, it'll be handled by `Style/OneLineConditional`
           return if node.single_line?

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

@@ -19,10 +19,23 @@ module RuboCop
         MSG = 'Empty interpolation detected.'
 
         def on_interpolation(begin_node)
-          return unless begin_node.children.empty?
+          return if in_percent_literal_array?(begin_node)
+
+          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
+
+        private
+
+        def in_percent_literal_array?(begin_node)
+          array_node = begin_node.each_ancestor(:array).first
+          return false unless array_node
+
+          array_node.percent_literal?
+        end
       end
     end
   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

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

@@ -54,6 +54,18 @@ module RuboCop
           end
         end
 
+        def on_or(node)
+          return unless node.lhs.falsey_literal?
+
+          add_offense(node.lhs) do |corrector|
+            # Don't autocorrect `'foo' && return` because having `return` as
+            # the leftmost node can lead to a void value expression syntax error.
+            next if node.rhs.type?(:return, :break, :next)
+
+            corrector.replace(node, node.rhs.source)
+          end
+        end
+
         def on_if(node)
           cond = condition(node)
 
@@ -123,7 +135,9 @@ module RuboCop
         # rubocop:enable Metrics/AbcSize
 
         def on_case(case_node)
-          if case_node.condition
+          if (cond = case_node.condition)
+            return if !cond.falsey_literal? && !cond.truthy_literal?
+
             check_case(case_node)
           else
             case_node.when_branches.each do |when_node|
@@ -228,7 +242,7 @@ module RuboCop
           )
         end
 
-        def condition_evaluation(node, cond)
+        def condition_evaluation?(node, cond)
           if node.unless?
             cond.falsey_literal?
           else
@@ -238,32 +252,28 @@ module RuboCop
 
         # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def correct_if_node(node, cond)
-          result = condition_evaluation(node, cond)
-
-          if node.elsif? && result
-            add_offense(cond) do |corrector|
-              corrector.replace(node, "else\n  #{node.if_branch.source}")
-            end
-          elsif node.elsif? && !result
-            add_offense(cond) do |corrector|
-              corrector.replace(node, "else\n  #{node.else_branch.source}")
-            end
-          elsif node.if_branch && result
-            add_offense(cond) do |corrector|
-              corrector.replace(node, node.if_branch.source)
-            end
-          elsif node.elsif_conditional?
-            add_offense(cond) do |corrector|
-              corrector.replace(node, "#{node.else_branch.source.sub('elsif', 'if')}\nend")
-            end
-          elsif node.else? || node.ternary?
-            add_offense(cond) do |corrector|
-              corrector.replace(node, node.else_branch.source)
-            end
-          else
-            add_offense(cond) do |corrector|
-              corrector.remove(node)
-            end
+          result = condition_evaluation?(node, cond)
+
+          new_node = if node.elsif? && result
+                       "else\n  #{range_with_comments(node.if_branch).source}"
+                     elsif node.elsif? && !result
+                       "else\n  #{node.else_branch.source}"
+                     elsif node.if_branch && result
+                       node.if_branch.source
+                     elsif node.elsif_conditional?
+                       "#{node.else_branch.source.sub('elsif', 'if')}\nend"
+                     elsif node.else? || node.ternary?
+                       node.else_branch.source
+                     else
+                       '' # Equivalent to removing the node
+                     end
+
+          add_offense(cond) do |corrector|
+            next if part_of_ignored_node?(node)
+
+            corrector.replace(node, new_node)
+
+            ignore_node(node)
           end
         end
         # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity

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

@@ -66,7 +66,7 @@ module RuboCop
 
         def special_keyword?(node)
           # handle strings like __FILE__
-          (node.str_type? && !node.loc.respond_to?(:begin)) || node.source_range.is?('__LINE__')
+          (node.str_type? && !node.loc?(:begin)) || node.source_range.is?('__LINE__')
         end
 
         def array_in_regexp?(node)

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

@@ -9,9 +9,21 @@ module RuboCop
       # cop disables on wide ranges of code, that latter contributors to
       # a file wouldn't be aware of.
       #
-      # @example
-      #   # Lint/MissingCopEnableDirective:
-      #   #   MaximumRangeSize: .inf
+      # You can set `MaximumRangeSize` to define the maximum number of
+      # consecutive lines a cop can be disabled for.
+      #
+      # - `.inf` any size (default)
+      # - `0` allows only single-line disables
+      # - `1` means the maximum allowed is as follows:
+      #
+      # [source,ruby]
+      # ----
+      # # rubocop:disable SomeCop
+      # a = 1
+      # # rubocop:enable SomeCop
+      # ----
+      #
+      # @example MaximumRangeSize: .inf (default)
       #
       #   # good
       #   # rubocop:disable Layout/SpaceAroundOperators
@@ -25,9 +37,7 @@ module RuboCop
       #   x= 0
       #   # EOF
       #
-      # @example
-      #   # Lint/MissingCopEnableDirective:
-      #   #   MaximumRangeSize: 2
+      # @example MaximumRangeSize: 2
       #
       #   # good
       #   # rubocop:disable Layout/SpaceAroundOperators
@@ -52,10 +62,9 @@ module RuboCop
           each_missing_enable do |cop, line_range|
             next if acceptable_range?(cop, line_range)
 
-            range = source_range(processed_source.buffer, line_range.min, 0..0)
             comment = processed_source.comment_at_line(line_range.begin)
 
-            add_offense(range, message: message(cop, comment))
+            add_offense(comment, message: message(cop, comment))
           end
         end
 

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

@@ -45,6 +45,10 @@ module RuboCop
             end
           end
         end
+        alias on_ivasgn on_lvasgn
+        alias on_cvasgn on_lvasgn
+        alias on_gvasgn on_lvasgn
+        alias on_casgn on_lvasgn
         alias on_or_asgn on_lvasgn
         alias on_op_asgn on_lvasgn
       end

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

@@ -45,6 +45,7 @@ module RuboCop
       #
       class NumericOperationWithConstantResult < Base
         extend AutoCorrector
+
         MSG = 'Numeric operation with a constant result detected.'
         RESTRICT_ON_SEND = %i[* / **].freeze
 

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

@@ -112,22 +112,36 @@ module RuboCop
 
         def each_line_range(cop, line_ranges)
           line_ranges.each_with_index do |line_range, line_range_index|
-            next if ignore_offense?(line_range)
-            next if expected_final_disable?(cop, line_range)
+            next if should_skip_line_range?(cop, line_range)
 
             comment = processed_source.comment_at_line(line_range.begin)
-            redundant = if all_disabled?(comment)
-                          find_redundant_all(line_range, line_ranges[line_range_index + 1])
-                        elsif department_disabled?(cop, comment)
-                          find_redundant_department(cop, line_range)
-                        else
-                          find_redundant_cop(cop, line_range)
-                        end
+            next if skip_directive?(comment)
 
+            next_range = line_ranges[line_range_index + 1]
+            redundant = find_redundant_directive(cop, comment, line_range, next_range)
             yield comment, redundant if redundant
           end
         end
 
+        def should_skip_line_range?(cop, line_range)
+          ignore_offense?(line_range) || expected_final_disable?(cop, line_range)
+        end
+
+        def skip_directive?(comment)
+          directive = DirectiveComment.new(comment)
+          directive.push? || directive.pop?
+        end
+
+        def find_redundant_directive(cop, comment, line_range, next_range)
+          if all_disabled?(comment)
+            find_redundant_all(line_range, next_range)
+          elsif department_disabled?(cop, comment)
+            find_redundant_department(cop, line_range)
+          else
+            find_redundant_cop(cop, line_range)
+          end
+        end
+
         # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def each_already_disabled(cop, line_ranges)
           line_ranges.each_cons(2) do |previous_range, range|

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

@@ -73,7 +73,7 @@ module RuboCop
         end
 
         def redundant_group?(expr)
-          expr.is?(:passive, :group) && expr.count { |child| child.type != :free_space } == 1
+          expr.is?(:passive, :group) && expr.one? { |child| child.type != :free_space }
         end
 
         def redundantly_quantifiable?(node)

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

@@ -19,7 +19,8 @@ module RuboCop
       #   * 2.2+ ... Add `rational` and `complex` above
       #   * 2.7+ ... Add `ruby2_keywords` above
       #   * 3.1+ ... Add `fiber` above
-      #   * 3.2+ ... `set`
+      #   * 3.2+ ... Add `set` above
+      #   * 4.0+ ... Add `pathname` above
       #
       # This cop target those features.
       #
@@ -69,7 +70,8 @@ module RuboCop
             (target_ruby_version >= 2.2 && RUBY_22_LOADED_FEATURES.include?(feature_name)) ||
             (target_ruby_version >= 2.7 && feature_name == 'ruby2_keywords') ||
             (target_ruby_version >= 3.1 && feature_name == 'fiber') ||
-            (target_ruby_version >= 3.2 && feature_name == 'set')
+            (target_ruby_version >= 3.2 && feature_name == 'set') ||
+            (target_ruby_version >= 4.0 && feature_name == 'pathname')
         end
         # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       end

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

@@ -20,6 +20,15 @@ module RuboCop
       # In the example below, the safe navigation operator (`&.`) is unnecessary
       # because `NilClass` has methods like `respond_to?` and `is_a?`.
       #
+      # The `InferNonNilReceiver` option specifies whether to look into previous code
+      # paths to infer if the receiver can't be nil. This check is unsafe because the receiver
+      # can be redefined between the safe navigation call and previous regular method call.
+      # It does the inference only in the current scope, e.g. within the same method definition etc.
+      #
+      # The `AdditionalNilMethods` option specifies additional custom methods which are
+      # defined on `NilClass`. When `InferNonNilReceiver` is set, they are used to determine
+      # whether the receiver can be nil.
+      #
       # @safety
       #   This cop is unsafe, because autocorrection can change the return type of
       #   the expression. An offending expression that previously could return `nil`
@@ -33,6 +42,20 @@ module RuboCop
       #   CamelCaseConst.do_something
       #
       #   # bad
+      #   foo.to_s&.strip
+      #   foo.to_i&.zero?
+      #   foo.to_f&.zero?
+      #   foo.to_a&.size
+      #   foo.to_h&.size
+      #
+      #   # good
+      #   foo.to_s.strip
+      #   foo.to_i.zero?
+      #   foo.to_f.zero?
+      #   foo.to_a.size
+      #   foo.to_h.size
+      #
+      #   # bad
       #   do_something if attrs&.respond_to?(:[])
       #
       #   # good
@@ -81,17 +104,59 @@ module RuboCop
       #   do_something if attrs.nil_safe_method(:[])
       #   do_something if attrs&.not_nil_safe_method(:[])
       #
+      # @example InferNonNilReceiver: false (default)
+      #   # good
+      #   foo.bar
+      #   foo&.baz
+      #
+      # @example InferNonNilReceiver: true
+      #   # bad
+      #   foo.bar
+      #   foo&.baz # would raise on previous line if `foo` is nil
+      #
+      #   # good
+      #   foo.bar
+      #   foo.baz
+      #
+      #   # bad
+      #   if foo.condition?
+      #     foo&.bar
+      #   end
+      #
+      #   # good
+      #   if foo.condition?
+      #     foo.bar
+      #   end
+      #
+      #   # good (different scopes)
+      #   def method1
+      #     foo.bar
+      #   end
+      #
+      #   def method2
+      #     foo&.bar
+      #   end
+      #
+      # @example AdditionalNilMethods: [present?]
+      #   # good
+      #   foo.present?
+      #   foo&.bar
+      #
       class RedundantSafeNavigation < Base
         include AllowedMethods
         extend AutoCorrector
 
         MSG = 'Redundant safe navigation detected, use `.` instead.'
         MSG_LITERAL = 'Redundant safe navigation with default literal detected.'
+        MSG_NON_NIL = 'Redundant safe navigation on non-nil receiver (detected by analyzing ' \
+                      'previous code/method invocations).'
 
         NIL_SPECIFIC_METHODS = (nil.methods - Object.new.methods).to_set.freeze
 
         SNAKE_CASE = /\A[[:digit:][:upper:]_]+\z/.freeze
 
+        GUARANTEED_INSTANCE_METHODS = %i[to_s to_i to_f to_a to_h].freeze
+
         # @!method respond_to_nil_specific_method?(node)
         def_node_matcher :respond_to_nil_specific_method?, <<~PATTERN
           (csend _ :respond_to? (sym %NIL_SPECIFIC_METHODS))
@@ -111,15 +176,27 @@ module RuboCop
 
         # rubocop:disable Metrics/AbcSize
         def on_csend(node)
+          range = node.loc.dot
+
+          if infer_non_nil_receiver?
+            checker = Lint::Utils::NilReceiverChecker.new(node.receiver, additional_nil_methods)
+
+            if checker.cant_be_nil?
+              add_offense(range, message: MSG_NON_NIL) { |corrector| corrector.replace(range, '.') }
+              return
+            end
+          end
+
           unless assume_receiver_instance_exists?(node.receiver)
-            return unless check?(node) && allowed_method?(node.method_name)
+            return if !guaranteed_instance?(node.receiver) && !check?(node)
             return if respond_to_nil_specific_method?(node)
           end
 
-          range = node.loc.dot
           add_offense(range) { |corrector| corrector.replace(range, '.') }
         end
+        # rubocop:enable Metrics/AbcSize
 
+        # rubocop:disable Metrics/AbcSize
         def on_or(node)
           conversion_with_default?(node) do |send_node|
             range = send_node.loc.dot.begin.join(node.source_range.end)
@@ -142,7 +219,20 @@ module RuboCop
           receiver.self_type? || (receiver.literal? && !receiver.nil_type?)
         end
 
+        def guaranteed_instance?(node)
+          receiver = if node.any_block_type?
+                       node.send_node
+                     else
+                       node
+                     end
+          return false unless receiver.send_type?
+
+          GUARANTEED_INSTANCE_METHODS.include?(receiver.method_name)
+        end
+
         def check?(node)
+          return false unless allowed_method?(node.method_name)
+
           parent = node.parent
           return false unless parent
 
@@ -154,6 +244,15 @@ module RuboCop
         def condition?(parent, node)
           (parent.conditional? || parent.post_condition_loop?) && parent.condition == node
         end
+
+        def infer_non_nil_receiver?
+          cop_config['InferNonNilReceiver']
+        end
+
+        def additional_nil_methods
+          @additional_nil_methods ||=
+            Array(cop_config.fetch('AdditionalNilMethods', []).map(&:to_sym))
+        end
       end
     end
   end

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

@@ -144,7 +144,9 @@ module RuboCop
             expression = node.parent.source_range if node.parent.array_type?
             [expression, variable.source]
           elsif !variable.array_type?
-            [expression, "[#{variable.source}]"]
+            replacement = variable.source
+            replacement = "[#{replacement}]" if wrap_in_brackets?(node)
+            [expression, replacement]
           elsif redundant_brackets?(node)
             [expression, remove_brackets(variable)]
           else
@@ -176,6 +178,10 @@ module RuboCop
             grandparent&.resbody_type?
         end
 
+        def wrap_in_brackets?(node)
+          node.parent.array_type? && !node.parent.bracketed?
+        end
+
         def remove_brackets(array)
           array_start = array.loc.begin.source
           elements = *array