rubocop 1.71.1 → 1.91.0

data/lib/rubocop/cop/style/redundant_condition.rb

@@ -42,7 +42,31 @@ module RuboCop
       #     c
       #   end
       #
+      #   # bad
+      #   a.nil? ? true : a
+      #
+      #   # good
+      #   a.nil? || a
+      #
+      #   # bad
+      #   if a.nil?
+      #     true
+      #   else
+      #     a
+      #   end
+      #
+      #   # good
+      #   a.nil? || a
+      #
+      # @example AllowedMethods: ['infinite?', 'nonzero?'] (default)
+      #   # good
+      #   num.infinite? ? true : false
+      #
+      #   # good
+      #   num.nonzero? ? true : false
+      #
       class RedundantCondition < Base
+        include AllowedMethods
         include CommentsHelp
         include RangeHelp
         extend AutoCorrector
@@ -95,7 +119,7 @@ module RuboCop
         end
 
         def offense?(node)
-          _condition, _if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring
+          _condition, _if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring -- takes all three branches in one step
           return false if use_if_branch?(else_branch) || use_hash_key_assignment?(else_branch)
 
           synonymous_condition_and_branch?(node) && !node.elsif? &&
@@ -119,7 +143,7 @@ module RuboCop
         end
 
         def synonymous_condition_and_branch?(node)
-          condition, if_branch, _else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring
+          condition, if_branch, _else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring -- takes all three branches in one step
           # e.g.
           #   if var
           #     var
@@ -128,6 +152,16 @@ module RuboCop
           #   end
           return true if condition == if_branch
 
+          # e.g.
+          #   a.nil? ? true : a
+          # or
+          #   if a.nil?
+          #     true
+          #   else
+          #     a
+          #   end
+          return true if if_branch_is_true_type_and_else_is_not?(node)
+
           # e.g.
           #   if foo
           #     @value = foo
@@ -146,8 +180,19 @@ module RuboCop
             !use_hash_key_access?(if_branch)
         end
 
+        # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def if_branch_is_true_type_and_else_is_not?(node)
+          return false unless node.ternary? || node.if?
+
+          cond = node.condition
+          return false unless cond.call_type?
+          return false if !cond.predicate_method? || allowed_method?(cond.method_name)
+
+          node.if_branch&.true_type? && node.else_branch && !node.else_branch.true_type?
+        end
+
         def branches_have_assignment?(node)
-          _condition, if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring
+          _condition, if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring -- takes all three branches in one step
 
           return false unless if_branch && else_branch
 
@@ -157,7 +202,7 @@ module RuboCop
         end
 
         def asgn_type?(node)
-          node.type?(:lvasgn, :ivasgn, :cvasgn, :gvasgn)
+          node.type?(:lvasgn, :ivasgn, :cvasgn, :gvasgn, :casgn)
         end
 
         def branches_have_method?(node)
@@ -187,6 +232,14 @@ module RuboCop
           node.type?(:kwsplat, :forwarded_kwrestarg)
         end
 
+        def wrap_arguments_with_parens(condition)
+          method = condition.source_range.begin.join(condition.loc.selector.end)
+          arguments = condition.first_argument.source_range.begin.join(condition.source_range.end)
+
+          "#{method.source}(#{arguments.source})"
+        end
+
+        # rubocop:disable-next Metrics/AbcSize
         def if_source(if_branch, arithmetic_operation)
           if branches_have_method?(if_branch.parent) && if_branch.parenthesized?
             if_branch.source.delete_suffix(')')
@@ -194,6 +247,11 @@ module RuboCop
             argument_source = if_branch.first_argument.source
 
             "#{if_branch.receiver.source} #{if_branch.method_name} (#{argument_source}"
+          elsif if_branch.true_type?
+            condition = if_branch.parent.condition
+            return condition.source if condition.arguments.empty? || condition.parenthesized?
+
+            wrap_arguments_with_parens(condition)
           else
             if_branch.source
           end
@@ -236,7 +294,7 @@ module RuboCop
         end
 
         def make_ternary_form(node)
-          _condition, if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring
+          _condition, if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring -- takes all three branches in one step
           arithmetic_operation = use_arithmetic_operation?(if_branch)
 
           ternary_form = [

data/lib/rubocop/cop/style/redundant_constant_base.rb

@@ -3,16 +3,21 @@
 module RuboCop
   module Cop
     module Style
-      # Avoid redundant `::` prefix on constant.
+      # Avoid redundant `::` prefix on a constant.
       #
-      # How Ruby searches constant is a bit complicated, and it can often be difficult to
+      # How Ruby searches constants is a bit complicated, and it can often be difficult to
       # understand from the code whether the `::` is intended or not. Where `Module.nesting`
       # is empty, there is no need to prepend `::`, so it would be nice to consistently
       # avoid such meaningless `::` prefix to avoid confusion.
       #
-      # NOTE: This cop is disabled if `Lint/ConstantResolution` cop is enabled to prevent
-      # conflicting rules. Because it respects user configurations that want to enable
-      # `Lint/ConstantResolution` cop which is disabled by default.
+      # NOTE: This cop is disabled if `Lint/ConstantResolution` cop is enabled,
+      # to prevent conflicting rules. This is because it respects user configurations
+      # that want to enable `Lint/ConstantResolution` cop which is disabled by default.
+      #
+      # When `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is
+      # installed, a leading `::` inside a namespace is also reported when the
+      # constant provably resolves to the same declaration with and without
+      # the base, i.e. nothing in the surrounding nesting shadows it.
       #
       # @example
       #   # bad
@@ -41,13 +46,14 @@ module RuboCop
       #     ::Const
       #   end
       class RedundantConstantBase < Base
+        include ProjectIndexHelp
         extend AutoCorrector
 
         MSG = 'Remove redundant `::`.'
 
         def on_cbase(node)
           return if lint_constant_resolution_cop_enabled?
-          return unless bad?(node)
+          return unless bad?(node) || provably_unshadowed?(node)
 
           add_offense(node) do |corrector|
             corrector.remove(node)
@@ -56,6 +62,36 @@ module RuboCop
 
         private
 
+        # When `AllCops/UseProjectIndex` is enabled, `::` inside a namespace is
+        # also redundant when the first constant segment resolves to the same
+        # declaration with and without the base, i.e. nothing in the
+        # surrounding nesting shadows it.
+        def provably_unshadowed?(node)
+          return false unless project_index
+          return false unless (segment = first_constant_segment(node))
+
+          nesting = module_nesting_ancestors_of(node)
+                    .map { |ancestor| ancestor.identifier.const_name }.reverse
+
+          !nesting.empty? && same_resolution?(segment, nesting)
+        rescue StandardError
+          false
+        end
+
+        def same_resolution?(segment, nesting)
+          relative = project_index.resolve_constant(segment, nesting)
+          absolute = project_index.resolve_constant(segment, [])
+
+          !relative.nil? && !absolute.nil? && relative.name == absolute.name
+        end
+
+        def first_constant_segment(node)
+          parent = node.parent
+          return nil unless parent&.const_type?
+
+          parent.short_name.to_s
+        end
+
         def lint_constant_resolution_cop_enabled?
           lint_constant_resolution_config.fetch('Enabled', false)
         end

data/lib/rubocop/cop/style/redundant_current_directory_in_path.rb

@@ -20,20 +20,42 @@ module RuboCop
 
         MSG = 'Remove the redundant current directory path.'
         RESTRICT_ON_SEND = %i[require_relative].freeze
-        CURRENT_DIRECTORY_PATH = './'
+        CURRENT_DIRECTORY_PREFIX = %r{\./+}.freeze
+        REDUNDANT_CURRENT_DIRECTORY_PREFIX = /\A#{CURRENT_DIRECTORY_PREFIX}/.freeze
 
         def on_send(node)
           return unless (first_argument = node.first_argument)
-          return unless first_argument.str_content&.start_with?(CURRENT_DIRECTORY_PATH)
-          return unless (index = first_argument.source.index(CURRENT_DIRECTORY_PATH))
+          return unless (index = first_argument.source.index(CURRENT_DIRECTORY_PREFIX))
+
+          content = leading_path_content(first_argument)
+          return unless (redundant_length = redundant_path_length(content))
 
           begin_pos = first_argument.source_range.begin.begin_pos + index
-          range = range_between(begin_pos, begin_pos + 2)
+          end_pos = begin_pos + redundant_length
+          range = range_between(begin_pos, end_pos)
 
           add_offense(range) do |corrector|
             corrector.remove(range)
           end
         end
+
+        private
+
+        # The literal text at the start of the path, which is the whole string
+        # for a plain string and the leading literal segment for an interpolated
+        # one (`nil` when it starts with interpolation).
+        def leading_path_content(node)
+          return node.str_content if node.str_type?
+          return unless node.dstr_type? && (first = node.children.first)&.str_type?
+
+          first.str_content
+        end
+
+        def redundant_path_length(path)
+          return unless (match = path&.match(REDUNDANT_CURRENT_DIRECTORY_PREFIX))
+
+          match[0].length
+        end
       end
     end
   end

data/lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb

@@ -25,7 +25,7 @@ module RuboCop
         MSG = 'Remove the redundant double splat and braces, use keyword arguments directly.'
         MERGE_METHODS = %i[merge merge!].freeze
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_hash(node)
           return if node.pairs.empty? || node.pairs.any?(&:hash_rocket?)
           return unless (parent = node.parent)
@@ -38,7 +38,6 @@ module RuboCop
             autocorrect(corrector, node, kwsplat)
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         private
 
@@ -109,7 +108,7 @@ module RuboCop
 
           node.arguments.map do |arg|
             if arg.hash_type?
-              arg.source
+              hash_argument_source(arg)
             else
               "**#{arg.source}"
             end
@@ -123,6 +122,15 @@ module RuboCop
 
           mergeable?(parent)
         end
+
+        # A braced hash literal passed to `merge` must have its braces stripped so
+        # its pairs join the surrounding keyword arguments. Keeping the braces would
+        # produce a positional hash after keyword arguments, which is invalid Ruby.
+        def hash_argument_source(hash)
+          return hash.source unless hash.braces?
+
+          hash.pairs.map(&:source).join(', ')
+        end
       end
     end
   end

data/lib/rubocop/cop/style/redundant_each.rb

@@ -60,11 +60,11 @@ module RuboCop
 
         private
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def redundant_each_method(node)
           return if node.last_argument&.block_pass_type?
 
-          if node.method?(:each) && !node.parent&.block_type?
+          if node.method?(:each) && !node.parent&.any_block_type?
             ancestor_node = node.each_ancestor(:call).detect do |ancestor|
               ancestor.receiver == node &&
                 (RESTRICT_ON_SEND.include?(ancestor.method_name) || ancestor.method?(:reverse_each))
@@ -74,14 +74,13 @@ module RuboCop
           end
 
           return unless (prev_method = node.children.first)
-          return if !prev_method.send_type? ||
-                    prev_method.parent.block_type? || prev_method.last_argument&.block_pass_type?
+          return if !prev_method.call_type? || prev_method.parent.any_block_type? ||
+                    prev_method.last_argument&.block_pass_type?
 
           detected = prev_method.method_name.to_s.start_with?('each_') unless node.method?(:each)
 
           prev_method if detected || prev_method.method?(:reverse_each)
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def range(node)
           return node.selector unless node.method?(:each)

data/lib/rubocop/cop/style/redundant_exception.rb

@@ -38,6 +38,10 @@ module RuboCop
 
         def fix_exploded(node)
           exploded?(node) do |command, message|
+            # `raise RuntimeError, nil` uses the class name as the message, so
+            # rewriting it to `raise nil.to_s` (an empty message) would change it.
+            next if message.nil_type?
+
             add_offense(node, message: MSG_1) do |corrector|
               corrector.replace(node, replaced_exploded(node, command, message))
             end
@@ -51,11 +55,13 @@ module RuboCop
         end
 
         def string_message?(message)
-          message.type?(:str, :dstr, :xstr)
+          message.any_str_type?
         end
 
         def fix_compact(node)
           compact?(node) do |new_call, message|
+            next if message.nil_type?
+
             add_offense(node, message: MSG_2) do |corrector|
               corrector.replace(new_call, replaced_compact(message))
             end

data/lib/rubocop/cop/style/redundant_fetch_block.rb

@@ -49,10 +49,10 @@ module RuboCop
           (block
             $(call _ :fetch _)
             (args)
-            ${nil? #basic_literal? #const_type?})
+            ${nil? basic_literal? const_type?})
         PATTERN
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler -- the matched body is a literal or a constant
           redundant_fetch_block_candidate?(node) do |send, body|
             return if should_not_check?(send, body)
 
@@ -71,14 +71,6 @@ module RuboCop
 
         private
 
-        def basic_literal?(node)
-          node&.basic_literal?
-        end
-
-        def const_type?(node)
-          node&.const_type?
-        end
-
         def should_not_check?(send, body)
           (body&.const_type? && !check_for_constant?) ||
             (body&.str_type? && !check_for_string?) ||

data/lib/rubocop/cop/style/redundant_file_extension_in_require.rb

@@ -41,6 +41,10 @@ module RuboCop
             return unless name_node.value.end_with?('.rb')
 
             extension_range = extension_range(name_node)
+            # A backslash right before the extension means the path is escaped;
+            # dropping the extension would either produce invalid Ruby (a trailing
+            # backslash escaping the closing quote) or a confusing path, so skip it.
+            return if escaped_extension?(name_node, extension_range)
 
             add_offense(extension_range) do |corrector|
               corrector.remove(extension_range)
@@ -55,6 +59,11 @@ module RuboCop
 
           range_between(end_of_path_string - 4, end_of_path_string - 1)
         end
+
+        def escaped_extension?(name_node, extension_range)
+          offset = extension_range.begin_pos - name_node.source_range.begin_pos
+          name_node.source[0...offset].end_with?('\\')
+        end
       end
     end
   end

data/lib/rubocop/cop/style/redundant_filter_chain.rb

@@ -62,7 +62,7 @@ module RuboCop
         def_node_matcher :select_predicate?, <<~PATTERN
           (call
             {
-              (block $(call _ {:select :filter :find_all}) ...)
+              (any_block $(call _ {:select :filter :find_all}) ...)
               $(call _ {:select :filter :find_all} block_pass_type?)
             }
             ${:#{RESTRICT_ON_SEND.join(' :')}})