rubocop 1.66.0 → 1.67.0

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

@@ -57,6 +57,7 @@ module RuboCop
       #   # good
       #   (a.foo)..(b.bar)
       class AmbiguousRange < Base
+        include RationalLiteral
         extend AutoCorrector
 
         MSG = 'Wrap complex range boundaries with parentheses to avoid ambiguity.'
@@ -79,12 +80,14 @@ module RuboCop
           yield range.end if range.end
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def acceptable?(node)
           node.begin_type? ||
-            node.literal? ||
+            node.literal? || rational_literal?(node) ||
             node.variable? || node.const_type? || node.self_type? ||
             (node.call_type? && acceptable_call?(node))
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def acceptable_call?(node)
           return true if node.unary_operation?

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

@@ -17,8 +17,7 @@ module RuboCop
       class BigDecimalNew < Base
         extend AutoCorrector
 
-        MSG = '`%<double_colon>sBigDecimal.new()` is deprecated. ' \
-              'Use `%<double_colon>sBigDecimal()` instead.'
+        MSG = '`BigDecimal.new()` is deprecated. Use `BigDecimal()` instead.'
         RESTRICT_ON_SEND = %i[new].freeze
 
         # @!method big_decimal_new(node)
@@ -28,13 +27,11 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          big_decimal_new(node) do |captured_value|
-            double_colon = captured_value ? '::' : ''
-            message = format(MSG, double_colon: double_colon)
-
-            add_offense(node.loc.selector, message: message) do |corrector|
+          big_decimal_new(node) do |cbase|
+            add_offense(node.loc.selector) do |corrector|
               corrector.remove(node.loc.selector)
               corrector.remove(node.loc.dot)
+              corrector.remove(cbase) if cbase
             end
           end
         end

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

@@ -36,7 +36,7 @@ module RuboCop
           return unless boolean_symbol?(node)
 
           parent = node.parent
-          return if parent&.array_type? && parent&.percent_literal?(:symbol)
+          return if parent&.array_type? && parent.percent_literal?(:symbol)
 
           add_offense(node, message: format(MSG, boolean: node.value)) do |corrector|
             autocorrect(corrector, node)

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for duplicate literal, constant, or variable elements in Set.
+      #
+      # @example
+      #
+      #   # bad
+      #   Set[:foo, :bar, :foo]
+      #
+      #   # good
+      #   Set[:foo, :bar]
+      #
+      #   # bad
+      #   Set.new([:foo, :bar, :foo])
+      #
+      #   # good
+      #   Set.new([:foo, :bar])
+      #
+      #   # bad
+      #   [:foo, :bar, :foo].to_set
+      #
+      #   # good
+      #   [:foo, :bar].to_set
+      #
+      class DuplicateSetElement < Base
+        extend AutoCorrector
+
+        MSG = 'Remove the duplicate element in Set.'
+        RESTRICT_ON_SEND = %i[\[\] new to_set].freeze
+
+        # @!method set_init_elements(node)
+        def_node_matcher :set_init_elements, <<~PATTERN
+          {
+            (send (const {nil? cbase} :Set) :[] $...)
+            (send (const {nil? cbase} :Set) :new (array $...))
+            (call (array $...) :to_set)
+          }
+        PATTERN
+
+        def on_send(node)
+          return unless (set_elements = set_init_elements(node))
+
+          seen_elements = Set[]
+
+          set_elements.each_with_index do |set_element, index|
+            # NOTE: Skip due to the possibility of corner cases where Set elements
+            # may have changing return values if they are not literals, constants, or variables.
+            next if !set_element.literal? && !set_element.const_type? && !set_element.variable?
+
+            if seen_elements.include?(set_element)
+              register_offense(set_element, set_elements[index - 1])
+            else
+              seen_elements << set_element
+            end
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def register_offense(current_element, prev_element)
+          add_offense(current_element) do |corrector|
+            range = prev_element.source_range.end.join(current_element.source_range.end)
+
+            corrector.remove(range)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -40,9 +40,6 @@ module RuboCop
       #     cleanup
       #   end
       class EnsureReturn < Base
-        extend AutoCorrector
-        include RangeHelp
-
         MSG = 'Do not return from an `ensure` block.'
 
         def on_ensure(node)

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

@@ -91,7 +91,7 @@ module RuboCop
               next if !argument || argument.hash_type?
 
               add_offense(
-                argument.source_range, message: message(i, argument.source)
+                argument, message: message(i, argument.source)
               ) do |corrector|
                 autocorrect(corrector, node)
               end

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

@@ -18,7 +18,7 @@ module RuboCop
       #   # good - using BigDecimal
       #   x.to_d == 0.1.to_d
       #
-      #  # good - comparing against zero
+      #   # good - comparing against zero
       #   x == 0.0
       #   x != 0.0
       #

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

@@ -28,7 +28,7 @@ module RuboCop
         FOR_METHOD = ' Or, if they were intended to be separate method ' \
                      'arguments, separate them with a comma.'
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
         def on_dstr(node)
           each_bad_cons(node) do |lhs_node, rhs_node|
             range = lhs_node.source_range.join(rhs_node.source_range)
@@ -40,13 +40,19 @@ module RuboCop
             end
 
             add_offense(range, message: message) do |corrector|
-              range = lhs_node.source_range.end.join(rhs_node.source_range.begin)
+              if lhs_node.value == ''
+                corrector.remove(lhs_node)
+              elsif rhs_node.value == ''
+                corrector.remove(rhs_node)
+              else
+                range = lhs_node.source_range.end.join(rhs_node.source_range.begin)
 
-              corrector.replace(range, ' + ')
+                corrector.replace(range, ' + ')
+              end
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize
+        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
 
         private
 

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

@@ -29,25 +29,16 @@ module RuboCop
 
         MSG = '`it` calls without arguments will refer to the first block param in Ruby 3.4; ' \
               'use `it()` or `self.it`.'
+        RESTRICT_ON_SEND = %i[it].freeze
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
-          return unless (body = node.body)
-          return unless node.arguments.empty_and_without_delimiters?
+        def on_send(node)
+          return unless (block_node = node.each_ancestor(:block).first)
+          return unless block_node.arguments.empty_and_without_delimiters?
 
-          if body.send_type? && deprecated_it_method?(body)
-            add_offense(body)
-          else
-            body.each_descendant(:send).each do |send_node|
-              next unless deprecated_it_method?(send_node)
-
-              add_offense(send_node)
-            end
-          end
+          add_offense(node) if deprecated_it_method?(node)
         end
 
         def deprecated_it_method?(node)
-          return false unless node.method?(:it)
-
           !node.receiver && node.arguments.empty? && !node.parenthesized? && !node.block_literal?
         end
       end

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

@@ -30,6 +30,8 @@ module RuboCop
           # interpolation should not be removed if the expanded value
           # contains a space character.
           expanded_value = autocorrected_value(final_node)
+          expanded_value = handle_special_regexp_chars(begin_node, expanded_value)
+
           return if in_array_percent_literal?(begin_node) && /\s|\A\z/.match?(expanded_value)
 
           add_offense(final_node) do |corrector|
@@ -77,6 +79,27 @@ module RuboCop
         end
         # rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity
 
+        def handle_special_regexp_chars(begin_node, value)
+          parent_node = begin_node.parent
+
+          return value unless parent_node.regexp_type? && parent_node.slash_literal? && value['/']
+
+          # When a literal string containing a forward slash preceded by backslashes
+          # is interpolated inside a regexp, the number of resultant backslashes in the
+          # compiled Regexp is `(2(n+1) / 4)+1`, where `n` is the number of backslashes
+          # inside the interpolation.
+          # ie. 0-2 backslashes is compiled to 1, 3-6 is compiled to 3, etc.
+          # This maintains that same behavior in order to ensure the Regexp behavior
+          # does not change upon removing the interpolation.
+          value.gsub(%r{(\\*)/}) do
+            backslashes = Regexp.last_match[1]
+            backslash_count = backslashes.length
+            needed_backslashes = (2 * ((backslash_count + 1) / 4)) + 1
+
+            "#{'\\' * needed_backslashes}/"
+          end
+        end
+
         def autocorrected_value_for_string(node)
           if node.source.start_with?("'", '%q')
             node.children.last.inspect[1..-2]
@@ -150,7 +173,7 @@ module RuboCop
 
         def ends_heredoc_line?(node)
           grandparent = node.parent.parent
-          return false unless grandparent&.dstr_type? && grandparent&.heredoc?
+          return false unless grandparent&.dstr_type? && grandparent.heredoc?
 
           line = processed_source.lines[node.last_line - 1]
           line.size == node.loc.last_column + 1
@@ -161,7 +184,7 @@ module RuboCop
           return false unless parent.dstr_type? || parent.dsym_type?
 
           grandparent = parent.parent
-          grandparent&.array_type? && grandparent&.percent_literal?
+          grandparent&.array_type? && grandparent.percent_literal?
         end
       end
     end

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

@@ -37,9 +37,7 @@ module RuboCop
         private
 
         def valid_context?(node)
-          unless node.arguments.one? && first_argument_starts_with_left_parenthesis?(node)
-            return true
-          end
+          return true unless node.arguments.one? && node.first_argument.parenthesized_call?
           return true if first_argument_block_type?(node.first_argument)
 
           node.operator_method? || node.setter_method? || chained_calls?(node) ||
@@ -51,11 +49,12 @@ module RuboCop
         end
 
         def valid_first_argument?(first_arg)
-          first_arg.operator_keyword? || first_arg.hash_type? || ternary_expression?(first_arg)
+          first_arg.operator_keyword? || first_arg.hash_type? || ternary_expression?(first_arg) ||
+            compound_range?(first_arg)
         end
 
-        def first_argument_starts_with_left_parenthesis?(node)
-          node.first_argument.source.start_with?('(')
+        def compound_range?(first_arg)
+          first_arg.range_type? && first_arg.parenthesized_call?
         end
 
         def chained_calls?(node)

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

@@ -131,7 +131,7 @@ module RuboCop
         private
 
         def assume_receiver_instance_exists?(receiver)
-          return true if receiver.const_type? && !receiver.source.match?(SNAKE_CASE)
+          return true if receiver.const_type? && !receiver.short_name.match?(SNAKE_CASE)
 
           receiver.literal? && !receiver.nil_type?
         end

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

@@ -3,88 +3,152 @@
 module RuboCop
   module Cop
     module Lint
-      # Check to make sure that if safe navigation is used for a method
-      # call in an `&&` or `||` condition that safe navigation is used for all
-      # method calls on that same object.
+      # Check to make sure that if safe navigation is used in an `&&` or `||` condition,
+      # consistent and appropriate safe navigation, without excess or deficiency,
+      # is used for all method calls on the same object.
       #
       # @example
       #   # bad
-      #   foo&.bar && foo.baz
+      #   foo&.bar && foo&.baz
       #
-      #   # bad
-      #   foo.bar || foo&.baz
+      #   # good
+      #   foo&.bar && foo.baz
       #
       #   # bad
-      #   foo&.bar && (foobar.baz || foo.baz)
+      #   foo.bar && foo&.baz
       #
       #   # good
       #   foo.bar && foo.baz
       #
+      #   # bad
+      #   foo&.bar || foo.baz
+      #
       #   # good
       #   foo&.bar || foo&.baz
       #
+      #   # bad
+      #   foo.bar || foo&.baz
+      #
       #   # good
+      #   foo.bar || foo.baz
+      #
+      #   # bad
       #   foo&.bar && (foobar.baz || foo&.baz)
       #
+      #   # good
+      #   foo&.bar && (foobar.baz || foo.baz)
+      #
       class SafeNavigationConsistency < Base
-        include IgnoredNode
         include NilMethods
         extend AutoCorrector
 
-        MSG = 'Ensure that safe navigation is used consistently inside of `&&` and `||`.'
+        USE_DOT_MSG = 'Use `.` instead of unnecessary `&.`.'
+        USE_SAFE_NAVIGATION_MSG = 'Use `&.` for consistency with safe navigation.'
+
+        def on_and(node)
+          all_operands = collect_operands(node, [])
+          operand_groups = all_operands.group_by { |operand| receiver_name_as_key(operand, +'') }
+
+          operand_groups.each_value do |grouped_operands|
+            next unless (dot_op, begin_of_rest_operands = find_consistent_parts(grouped_operands))
 
-        def on_csend(node)
-          return unless node.parent&.operator_keyword?
+            rest_operands = grouped_operands[begin_of_rest_operands..]
+            rest_operands.each do |operand|
+              next if already_appropriate_call?(operand, dot_op)
 
-          check(node)
+              register_offense(operand, dot_op)
+            end
+          end
         end
+        alias on_or on_and
 
-        def check(node)
-          ancestor = top_conditional_ancestor(node)
-          conditions = ancestor.conditions
-          safe_nav_receiver = node.receiver
+        private
 
-          method_calls = conditions.select(&:send_type?)
-          unsafe_method_calls = unsafe_method_calls(method_calls, safe_nav_receiver)
+        def collect_operands(node, operand_nodes)
+          operand_nodes(node.lhs, operand_nodes)
+          operand_nodes(node.rhs, operand_nodes)
 
-          unsafe_method_calls.each do |unsafe_method_call|
-            location = location(node, unsafe_method_call)
+          operand_nodes
+        end
 
-            add_offense(location) { |corrector| autocorrect(corrector, unsafe_method_call) }
+        def receiver_name_as_key(method, fully_receivers)
+          if method.parent.call_type?
+            receiver(method.parent, fully_receivers)
+          else
+            fully_receivers << method.receiver&.source.to_s
+          end
+        end
 
-            ignore_node(unsafe_method_call)
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def find_consistent_parts(grouped_operands)
+          csend_in_and, csend_in_or, send_in_and, send_in_or = most_left_indices(grouped_operands)
+
+          if csend_in_and
+            ['.', (send_in_and ? [send_in_and, csend_in_and].min : csend_in_and) + 1]
+          elsif send_in_or && csend_in_or
+            send_in_or < csend_in_or ? ['.', send_in_or + 1] : ['&.', csend_in_or + 1]
+          elsif send_in_and && csend_in_or && send_in_and < csend_in_or
+            ['.', csend_in_or]
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
-        private
+        def already_appropriate_call?(operand, dot_op)
+          (operand.safe_navigation? && dot_op == '&.') || (operand.dot? && dot_op == '.')
+        end
+
+        def register_offense(operand, dot_operator)
+          offense_range = operand.operator_method? ? operand : operand.loc.dot
+          message = dot_operator == '.' ? USE_DOT_MSG : USE_SAFE_NAVIGATION_MSG
 
-        def autocorrect(corrector, node)
-          return unless node.dot?
+          add_offense(offense_range, message: message) do |corrector|
+            next if operand.operator_method?
 
-          corrector.insert_before(node.loc.dot, '&')
+            corrector.replace(operand.loc.dot, dot_operator)
+          end
         end
 
-        def location(node, unsafe_method_call)
-          node.source_range.join(unsafe_method_call.source_range)
+        def operand_nodes(operand, operand_nodes)
+          if operand.operator_keyword?
+            collect_operands(operand, operand_nodes)
+          elsif operand.call_type?
+            operand_nodes << operand
+          end
         end
 
-        def top_conditional_ancestor(node)
-          parent = node.parent
-          unless parent &&
-                 (parent.operator_keyword? ||
-                  (parent.begin_type? && parent.parent && parent.parent.operator_keyword?))
-            return node
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def most_left_indices(grouped_operands)
+          indices = { csend_in_and: nil, csend_in_or: nil, send_in_and: nil, send_in_or: nil }
+
+          grouped_operands.each_with_index do |operand, index|
+            indices[:csend_in_and] ||= index if operand_in_and?(operand) && operand.csend_type?
+            indices[:csend_in_or] ||= index if operand_in_or?(operand) && operand.csend_type?
+            indices[:send_in_and] ||= index if operand_in_and?(operand) && !nilable?(operand)
+            indices[:send_in_or] ||= index if operand_in_or?(operand) && !nilable?(operand)
           end
 
-          top_conditional_ancestor(parent)
+          indices.values
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
-        def unsafe_method_calls(method_calls, safe_nav_receiver)
-          method_calls.select do |method_call|
-            safe_nav_receiver == method_call.receiver &&
-              !nil_methods.include?(method_call.method_name) &&
-              !ignored_node?(method_call)
-          end
+        def operand_in_and?(node)
+          return true if node.parent.and_type?
+
+          parent = node.parent.parent while node.parent.begin_type?
+
+          parent&.and_type?
+        end
+
+        def operand_in_or?(node)
+          return true if node.parent.or_type?
+
+          parent = node.parent.parent while node.parent.begin_type?
+
+          parent&.or_type?
+        end
+
+        def nilable?(node)
+          node.csend_type? || nil_methods.include?(node.method_name)
         end
       end
     end

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

@@ -141,7 +141,7 @@ module RuboCop
         end
 
         def in_percent_literal_array?(node)
-          node.parent&.array_type? && node.parent&.percent_literal?
+          node.parent&.array_type? && node.parent.percent_literal?
         end
 
         def correct_hash_key(node)

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

@@ -3,29 +3,47 @@
 module RuboCop
   module Cop
     module Lint
-      # Identifies places where `URI.regexp` is obsolete and should
-      # not be used. Instead, use `URI::DEFAULT_PARSER.make_regexp`.
+      # Identifies places where `URI.regexp` is obsolete and should not be used.
+      #
+      # For Ruby 3.3 or lower, use `URI::DEFAULT_PARSER.make_regexp`.
+      # For Ruby 3.4 or higher, use `URI::RFC2396_PARSER.make_regexp`.
+      #
+      # NOTE: If you need to support both Ruby 3.3 and lower as well as Ruby 3.4 and higher,
+      # consider manually changing the code as follows:
+      #
+      # [source,ruby]
+      # ----
+      # defined?(URI::RFC2396_PARSER) ? URI::RFC2396_PARSER : URI::DEFAULT_PARSER
+      # ----
       #
       # @example
       #   # bad
       #   URI.regexp('http://example.com')
       #
-      #   # good
+      #   # good - Ruby 3.3 or lower
       #   URI::DEFAULT_PARSER.make_regexp('http://example.com')
       #
+      #   # good - Ruby 3.4 or higher
+      #   URI::RFC2396_PARSER.make_regexp('http://example.com')
+      #
       class UriRegexp < Base
         extend AutoCorrector
 
         MSG = '`%<current>s` is obsolete and should not be used. Instead, use `%<preferred>s`.'
-        URI_CONSTANTS = ['URI', '::URI'].freeze
         RESTRICT_ON_SEND = %i[regexp].freeze
 
+        # @!method uri_constant?(node)
+        def_node_matcher :uri_constant?, <<~PATTERN
+          (const {cbase nil?} :URI)
+        PATTERN
+
         def on_send(node)
-          return unless node.receiver
-          return unless URI_CONSTANTS.include?(node.receiver.source)
+          return unless uri_constant?(node.receiver)
 
+          parser = target_ruby_version >= 3.4 ? 'RFC2396_PARSER' : 'DEFAULT_PARSER'
           argument = node.first_argument ? "(#{node.first_argument.source})" : ''
-          preferred_method = "#{node.receiver.source}::DEFAULT_PARSER.make_regexp#{argument}"
+
+          preferred_method = "#{node.receiver.source}::#{parser}.make_regexp#{argument}"
           message = format(MSG, current: node.source, preferred: preferred_method)
 
           add_offense(node.loc.selector, message: message) do |corrector|

data/lib/rubocop/cop/mixin/percent_array.rb

@@ -15,7 +15,7 @@ module RuboCop
         parent = node.parent
 
         parent&.send_type? && parent.arguments.include?(node) &&
-          !parent.parenthesized? && parent&.block_literal?
+          !parent.parenthesized? && parent.block_literal?
       end
 
       # Override to determine values that are invalid in a percent array

data/lib/rubocop/cop/mixin/statement_modifier.rb

@@ -5,7 +5,6 @@ module RuboCop
     # Common functionality for modifier cops.
     module StatementModifier
       include LineLengthHelp
-      include RangeHelp
 
       private
 
@@ -65,7 +64,9 @@ module RuboCop
       end
 
       def method_source(if_body)
-        range_between(if_body.source_range.begin_pos, if_body.loc.selector.end_pos).source
+        end_range = if_body.implicit_call? ? if_body.loc.dot.end : if_body.loc.selector
+
+        if_body.source_range.begin.join(end_range).source
       end
 
       def first_line_comment(node)

data/lib/rubocop/cop/naming/inclusive_language.rb

@@ -116,9 +116,9 @@ module RuboCop
             add_offense(range, message: create_message(word)) do |corrector|
               suggestions = find_flagged_term(word)['Suggestions']
 
-              next unless suggestions.is_a?(String)
-
-              corrector.replace(range, suggestions)
+              if (preferred_term = preferred_sole_term(suggestions))
+                corrector.replace(range, preferred_term)
+              end
             end
           end
         end
@@ -157,6 +157,15 @@ module RuboCop
           set_regexes(flagged_term_strings, allowed_strings)
         end
 
+        def preferred_sole_term(suggestions)
+          case suggestions
+          when Array
+            suggestions.one? && preferred_sole_term(suggestions.first)
+          when String
+            suggestions
+          end
+        end
+
         def extract_regexp(term, term_definition)
           return term_definition['Regex'] if term_definition['Regex']
           return /(?:\b|(?<=[\W_]))#{term}(?:\b|(?=[\W_]))/ if term_definition['WholeWord']

data/lib/rubocop/cop/naming/predicate_name.rb

@@ -88,7 +88,7 @@ module RuboCop
               next if allowed_method_name?(method_name.to_s, prefix)
 
               add_offense(
-                node.first_argument.source_range,
+                node.first_argument,
                 message: message(method_name, expected_name(method_name.to_s, prefix))
               )
             end

data/lib/rubocop/cop/offense.rb

@@ -97,8 +97,8 @@ module RuboCop
       # @!attribute [r] correctable?
       #
       # @return [Boolean]
-      #   whether this offense can be automatically corrected via
-      #   autocorrect or a todo.
+      #   whether this offense can be automatically corrected via autocorrect.
+      #   This includes todo comments, for example when requested with `--disable-uncorrectable`.
       def correctable?
         @status != :unsupported
       end