rubocop 1.53.0 → 1.90.0

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

@@ -3,9 +3,9 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for redundant `begin` blocks.
-      #
-      # Currently it checks for code like this:
+      # Checks for redundant `begin` blocks. A `begin` block is redundant
+      # when the `rescue`/`ensure` can be handled by the enclosing method
+      # or block definition directly, avoiding unnecessary indentation.
       #
       # @example
       #
@@ -68,6 +68,10 @@ module RuboCop
 
         MSG = 'Redundant `begin` block detected.'
 
+        def self.autocorrect_incompatible_with
+          [Style::BlockDelimiters]
+        end
+
         # @!method offensive_kwbegins(node)
         def_node_search :offensive_kwbegins, <<~PATTERN
           [(kwbegin ...) !#allowable_kwbegin?]
@@ -75,12 +79,35 @@ module RuboCop
 
         def on_def(node)
           return unless node.body&.kwbegin_type?
-          return if node.endless? && !node.body.children.one?
+          return if node.endless?
 
           register_offense(node.body)
         end
         alias on_defs on_def
 
+        def on_if(node)
+          return if node.modifier_form?
+
+          inspect_branches(node)
+        end
+
+        def on_case(node)
+          inspect_branches(node)
+        end
+        alias on_case_match on_case
+
+        def on_while(node)
+          return if node.modifier_form?
+
+          body = node.body
+
+          return unless body&.kwbegin_type?
+          return if body.rescue_node || body.ensure_node
+
+          register_offense(body)
+        end
+        alias on_until on_while
+
         def on_block(node)
           return if target_ruby_version < 2.5
           return if node.send_node.lambda_literal?
@@ -91,6 +118,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         def on_kwbegin(node)
           return unless (target_node = offensive_kwbegins(node).to_a.last)
@@ -114,7 +142,7 @@ module RuboCop
             if node.parent&.assignment?
               replace_begin_with_statement(corrector, offense_range, node)
             else
-              corrector.remove(offense_range)
+              remove_begin(corrector, offense_range, node)
             end
 
             if use_modifier_form_after_multiline_begin_block?(node)
@@ -136,6 +164,14 @@ module RuboCop
           restore_removed_comments(corrector, offense_range, node, first_child)
         end
 
+        def remove_begin(corrector, offense_range, node)
+          if node.parent.respond_to?(:endless?) && node.parent.endless?
+            offense_range = range_with_surrounding_space(offense_range, newlines: true)
+          end
+
+          corrector.remove(offense_range)
+        end
+
         # Restore comments that occur between "begin" and "first_child".
         # These comments will be moved to above the assignment line.
         def restore_removed_comments(corrector, offense_range, node, first_child)
@@ -167,13 +203,15 @@ module RuboCop
         end
 
         def begin_block_has_multiline_statements?(node)
+          return false unless node.parent
+
           node.children.count >= 2
         end
 
         def contain_rescue_or_ensure?(node)
           first_child = node.children.first
 
-          first_child.rescue_type? || first_child.ensure_type?
+          first_child.type?(:rescue, :ensure)
         end
 
         def valid_context_using_only_begin?(node)
@@ -186,6 +224,15 @@ module RuboCop
         def valid_begin_assignment?(node)
           node.parent&.assignment? && !node.children.one?
         end
+
+        def inspect_branches(node)
+          node.branches.each do |branch|
+            next unless branch&.kwbegin_type?
+            next if branch.rescue_node || branch.ensure_node
+
+            register_offense(branch)
+          end
+        end
       end
     end
   end

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

@@ -5,6 +5,19 @@ module RuboCop
     module Style
       # Checks for unnecessary conditional expressions.
       #
+      # NOTE: Since the intention of the comment cannot be automatically determined,
+      # autocorrection is not applied when a comment is used, as shown below:
+      #
+      # [source,ruby]
+      # -----
+      # if b
+      #   # Important note.
+      #   b
+      # else
+      #   c
+      # end
+      # -----
+      #
       # @example
       #   # bad
       #   a = b ? b : c
@@ -12,7 +25,6 @@ module RuboCop
       #   # good
       #   a = b || c
       #
-      # @example
       #   # bad
       #   if b
       #     b
@@ -30,7 +42,32 @@ 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
 
@@ -41,21 +78,12 @@ module RuboCop
         ].freeze
 
         def on_if(node)
-          return if node.elsif_conditional?
-          return unless offense?(node)
+          return if node.modifier_form? || node.elsif_conditional? || !offense?(node)
 
           message = message(node)
 
           add_offense(range_of_offense(node), message: message) do |corrector|
-            if node.ternary? && !branches_have_method?(node)
-              correct_ternary(corrector, node)
-            elsif redundant_condition?(node)
-              corrector.replace(node, node.if_branch.source)
-            else
-              corrected = make_ternary_form(node)
-
-              corrector.replace(node, corrected)
-            end
+            autocorrect(corrector, node)
           end
         end
 
@@ -69,6 +97,20 @@ module RuboCop
           end
         end
 
+        def autocorrect(corrector, node)
+          return if node.each_descendant.any? { |descendant| contains_comments?(descendant) }
+
+          if node.ternary? && !branches_have_method?(node)
+            correct_ternary(corrector, node)
+          elsif redundant_condition?(node)
+            corrector.replace(node, node.if_branch.source)
+          else
+            corrected = make_ternary_form(node)
+
+            corrector.replace(node, corrected)
+          end
+        end
+
         def range_of_offense(node)
           return node.source_range unless node.ternary?
           return node.source_range if node.ternary? && branches_have_method?(node)
@@ -77,8 +119,7 @@ module RuboCop
         end
 
         def offense?(node)
-          _condition, _if_branch, else_branch = *node
-
+          _condition, _if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring
           return false if use_if_branch?(else_branch) || use_hash_key_assignment?(else_branch)
 
           synonymous_condition_and_branch?(node) && !node.elsif? &&
@@ -94,7 +135,7 @@ module RuboCop
         end
 
         def use_hash_key_assignment?(else_branch)
-          else_branch&.send_type? && else_branch&.method?(:[]=)
+          else_branch&.send_type? && else_branch.method?(:[]=)
         end
 
         def use_hash_key_access?(node)
@@ -102,7 +143,7 @@ module RuboCop
         end
 
         def synonymous_condition_and_branch?(node)
-          condition, if_branch, _else_branch = *node
+          condition, if_branch, _else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring
           # e.g.
           #   if var
           #     var
@@ -111,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
@@ -129,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
+          _condition, if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring
 
           return false unless if_branch && else_branch
 
@@ -140,16 +202,14 @@ module RuboCop
         end
 
         def asgn_type?(node)
-          node.lvasgn_type? || node.ivasgn_type? || node.cvasgn_type? || node.gvasgn_type?
+          node.type?(:lvasgn, :ivasgn, :cvasgn, :gvasgn, :casgn)
         end
 
         def branches_have_method?(node)
-          _condition, if_branch, else_branch = *node
-
-          return false unless if_branch && else_branch
+          return false unless node.if_branch && node.else_branch
 
-          single_argument_method?(if_branch) && single_argument_method?(else_branch) &&
-            same_method?(if_branch, else_branch)
+          single_argument_method?(node.if_branch) && single_argument_method?(node.else_branch) &&
+            same_method?(node.if_branch, node.else_branch)
         end
 
         def single_argument_method?(node)
@@ -169,9 +229,17 @@ module RuboCop
           return false unless argument.hash_type?
           return false unless (node = argument.children.first)
 
-          node.kwsplat_type? || node.forwarded_kwrestarg_type?
+          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(')')
@@ -179,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
@@ -221,7 +294,7 @@ module RuboCop
         end
 
         def make_ternary_form(node)
-          _condition, if_branch, else_branch = *node
+          _condition, if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring
           arithmetic_operation = use_arithmetic_operation?(if_branch)
 
           ternary_form = [

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

@@ -70,19 +70,11 @@ module RuboCop
 
         def replacement_condition(node)
           condition = node.condition.source
-          expression = invert_expression?(node) ? "!(#{condition})" : condition
+          expression = redundant_condition_inverted?(node) ? "!(#{condition})" : condition
 
           node.elsif? ? indented_else_node(expression, node) : expression
         end
 
-        def invert_expression?(node)
-          (
-            (node.if? || node.elsif? || node.ternary?) && redundant_condition_inverted?(node)
-          ) || (
-            node.unless? && redundant_condition?(node)
-          )
-        end
-
         def indented_else_node(expression, node)
           "else\n#{indentation(node)}#{expression}"
         end

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

@@ -3,7 +3,8 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for uses a redundant current directory in path.
+      # Checks for paths given to `require_relative` that start with
+      # the current directory (`./`), which can be omitted.
       #
       # @example
       #
@@ -18,20 +19,43 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Remove the redundant current directory path.'
-        CURRENT_DIRECTORY_PATH = './'
+        RESTRICT_ON_SEND = %i[require_relative].freeze
+        CURRENT_DIRECTORY_PREFIX = %r{\./+}.freeze
+        REDUNDANT_CURRENT_DIRECTORY_PREFIX = /\A#{CURRENT_DIRECTORY_PREFIX}/.freeze
 
         def on_send(node)
-          return unless node.method?(:require_relative)
-          return unless node.first_argument.str_content.start_with?(CURRENT_DIRECTORY_PATH)
-          return unless (index = node.first_argument.source.index(CURRENT_DIRECTORY_PATH))
+          return unless (first_argument = node.first_argument)
+          return unless (index = first_argument.source.index(CURRENT_DIRECTORY_PREFIX))
 
-          begin_pos = node.first_argument.source_range.begin.begin_pos + index
-          range = range_between(begin_pos, begin_pos + 2)
+          content = leading_path_content(first_argument)
+          return unless (redundant_length = redundant_path_length(content))
+
+          begin_pos = first_argument.source_range.begin.begin_pos + index
+          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

@@ -13,25 +13,70 @@ module RuboCop
       #   # good
       #   do_something(foo: bar, baz: qux)
       #
+      #   # bad
+      #   do_something(**{foo: bar, baz: qux}.merge(options))
+      #
+      #   # good
+      #   do_something(foo: bar, baz: qux, **options)
+      #
       class RedundantDoubleSplatHashBraces < Base
         extend AutoCorrector
 
         MSG = 'Remove the redundant double splat and braces, use keyword arguments directly.'
+        MERGE_METHODS = %i[merge merge!].freeze
 
+        # 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)
-          return unless parent.kwsplat_type?
+          return unless parent.type?(:call, :kwsplat)
+          return unless mergeable?(parent)
+          return unless (kwsplat = node.each_ancestor(:kwsplat).first)
+          return if !node.braces? || allowed_double_splat_receiver?(kwsplat)
 
-          add_offense(parent) do |corrector|
-            corrector.remove(parent.loc.operator)
-            corrector.remove(opening_brace(node))
-            corrector.remove(closing_brace(node))
+          add_offense(kwsplat) do |corrector|
+            autocorrect(corrector, node, kwsplat)
           end
         end
 
         private
 
+        def allowed_double_splat_receiver?(kwsplat)
+          first_child = kwsplat.children.first
+          return true if first_child.any_block_type?
+          return false unless first_child.call_type?
+
+          root_receiver = root_receiver(first_child)
+
+          !root_receiver&.hash_type?
+        end
+
+        def autocorrect(corrector, node, kwsplat)
+          corrector.remove(kwsplat.loc.operator)
+          corrector.remove(opening_brace(node))
+          corrector.remove(closing_brace(node))
+
+          merge_methods = select_merge_method_nodes(kwsplat)
+          return if merge_methods.empty?
+
+          autocorrect_merge_methods(corrector, merge_methods, kwsplat)
+        end
+
+        def root_receiver(node)
+          receiver = node.receiver
+          if receiver&.receiver
+            root_receiver(receiver)
+          else
+            receiver
+          end
+        end
+
+        def select_merge_method_nodes(kwsplat)
+          kwsplat.each_descendant(:call).select do |node|
+            mergeable?(node)
+          end
+        end
+
         def opening_brace(node)
           node.loc.begin.join(node.children.first.source_range.begin)
         end
@@ -39,6 +84,44 @@ module RuboCop
         def closing_brace(node)
           node.children.last.source_range.end.join(node.loc.end)
         end
+
+        def autocorrect_merge_methods(corrector, merge_methods, kwsplat)
+          range = range_of_merge_methods(merge_methods)
+
+          new_kwsplat_arguments = kwsplat.each_descendant(:call).map do |descendant|
+            convert_to_new_arguments(descendant)
+          end
+          new_source = new_kwsplat_arguments.compact.reverse.unshift('').join(', ')
+
+          corrector.replace(range, new_source)
+        end
+
+        def range_of_merge_methods(merge_methods)
+          begin_merge_method = merge_methods.last
+          end_merge_method = merge_methods.first
+
+          begin_merge_method.loc.dot.begin.join(end_merge_method.source_range.end)
+        end
+
+        def convert_to_new_arguments(node)
+          return unless mergeable?(node)
+
+          node.arguments.map do |arg|
+            if arg.hash_type?
+              arg.source
+            else
+              "**#{arg.source}"
+            end
+          end
+        end
+
+        def mergeable?(node)
+          return true unless node.call_type?
+          return false unless MERGE_METHODS.include?(node.method_name)
+          return true unless (parent = node.parent)
+
+          mergeable?(parent)
+        end
       end
     end
   end

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

@@ -56,15 +56,16 @@ module RuboCop
             end
           end
         end
+        alias on_csend on_send
 
         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?
-            ancestor_node = node.each_ancestor(:send).detect do |ancestor|
+          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))
             end
@@ -73,20 +74,21 @@ 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)
-          if node.method?(:each)
-            node.loc.dot.join(node.loc.selector)
+          return node.selector unless node.method?(:each)
+
+          if node.parent&.call_type?
+            node.selector.join(node.parent.loc.dot)
           else
-            node.loc.selector
+            node.loc.dot.join(node.selector)
           end
         end