rubocop 1.44.1 → 1.78.0

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

@@ -35,6 +35,8 @@ module RuboCop
       #   array.join('')
       #   [1, 2, 3].join("")
       #   array.sum(0)
+      #   exit(true)
+      #   exit!(false)
       #   string.split(" ")
       #   "first\nsecond".split(" ")
       #   string.chomp("\n")
@@ -45,6 +47,8 @@ module RuboCop
       #   array.join
       #   [1, 2, 3].join
       #   array.sum
+      #   exit
+      #   exit!
       #   string.split
       #   "first second".split
       #   string.chomp
@@ -55,19 +59,21 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Argument %<arg>s is redundant because it is implied by default.'
+        NO_RECEIVER_METHODS = %i[exit exit!].freeze
 
         def on_send(node)
-          return if node.receiver.nil?
+          return if !NO_RECEIVER_METHODS.include?(node.method_name) && node.receiver.nil?
           return if node.arguments.count != 1
           return unless redundant_argument?(node)
 
           offense_range = argument_range(node)
-          message = format(MSG, arg: node.arguments.first.source)
+          message = format(MSG, arg: node.first_argument.source)
 
           add_offense(offense_range, message: message) do |corrector|
             corrector.remove(offense_range)
           end
         end
+        alias on_csend on_send
 
         private
 
@@ -75,14 +81,20 @@ module RuboCop
           redundant_argument = redundant_arg_for_method(node.method_name.to_s)
           return false if redundant_argument.nil?
 
-          node.arguments.first == redundant_argument
+          target_argument = if node.first_argument.respond_to?(:value)
+                              node.first_argument.value
+                            else
+                              node.first_argument
+                            end
+
+          argument_matched?(target_argument, redundant_argument)
         end
 
         def redundant_arg_for_method(method_name)
           arg = cop_config['Methods'].fetch(method_name) { return }
 
           @mem ||= {}
-          @mem[method_name] ||= parse(arg.inspect).ast
+          @mem[method_name] ||= arg.inspect
         end
 
         def argument_range(node)
@@ -92,6 +104,25 @@ module RuboCop
             range_with_surrounding_space(node.first_argument.source_range, newlines: false)
           end
         end
+
+        def argument_matched?(target_argument, redundant_argument)
+          argument = if target_argument.is_a?(AST::Node)
+                       target_argument.source
+                     elsif exclude_cntrl_character?(target_argument, redundant_argument)
+                       target_argument.inspect
+                     else
+                       target_argument.to_s
+                     end
+
+          argument == redundant_argument
+        end
+
+        def exclude_cntrl_character?(target_argument, redundant_argument)
+          return true unless (target_argument_string = target_argument.to_s).valid_encoding?
+
+          !target_argument_string.sub(/\A'/, '"').sub(/'\z/, '"').match?(/[[:cntrl:]]/) ||
+            !redundant_argument.match?(/[[:cntrl:]]/)
+        end
       end
     end
   end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for the instantiation of array using redundant `Array` constructor.
+      # Autocorrect replaces to array literal which is the simplest and fastest.
+      #
+      # @example
+      #
+      #   # bad
+      #   Array.new([])
+      #   Array[]
+      #   Array([])
+      #   Array.new(['foo', 'foo', 'foo'])
+      #   Array['foo', 'foo', 'foo']
+      #   Array(['foo', 'foo', 'foo'])
+      #
+      #   # good
+      #   []
+      #   ['foo', 'foo', 'foo']
+      #   Array.new(3, 'foo')
+      #   Array.new(3) { 'foo' }
+      #
+      class RedundantArrayConstructor < Base
+        extend AutoCorrector
+
+        MSG = 'Remove the redundant `Array` constructor.'
+
+        RESTRICT_ON_SEND = %i[new [] Array].freeze
+
+        # @!method redundant_array_constructor(node)
+        def_node_matcher :redundant_array_constructor, <<~PATTERN
+          {
+            (send
+              (const {nil? cbase} :Array) :new
+              $(array ...))
+            (send
+              (const {nil? cbase} :Array) :[]
+              $...)
+            (send
+              nil? :Array
+              $(array ...))
+          }
+        PATTERN
+
+        def on_send(node)
+          return unless (array_literal = redundant_array_constructor(node))
+
+          receiver = node.receiver
+          selector = node.loc.selector
+
+          if node.method?(:new)
+            range = receiver.source_range.join(selector)
+            replacement = array_literal
+          elsif node.method?(:Array)
+            range = selector
+            replacement = array_literal
+          else
+            range = receiver
+            replacement = selector.begin.join(node.source_range.end)
+          end
+
+          register_offense(range, node, replacement)
+        end
+
+        private
+
+        def register_offense(range, node, replacement)
+          add_offense(range) do |corrector|
+            corrector.replace(node, replacement.source)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for redundant calls of `Array#flatten`.
+      #
+      # `Array#join` joins nested arrays recursively, so flattening an array
+      # beforehand is redundant.
+      #
+      # @safety
+      #   Cop is unsafe because the receiver of `flatten` method might not
+      #   be an `Array`, so it's possible it won't respond to `join` method,
+      #   or the end result would be different.
+      #   Also, if the global variable `$,` is set to a value other than the default `nil`,
+      #   false positives may occur.
+      #
+      # @example
+      #   # bad
+      #   x.flatten.join
+      #   x.flatten(1).join
+      #
+      #   # good
+      #   x.join
+      #
+      class RedundantArrayFlatten < Base
+        extend AutoCorrector
+
+        MSG = 'Remove the redundant `flatten`.'
+
+        RESTRICT_ON_SEND = %i[flatten].freeze
+
+        # @!method flatten_join?(node)
+        def_node_matcher :flatten_join?, <<~PATTERN
+          (call (call !nil? :flatten _?) :join (nil)?)
+        PATTERN
+
+        def on_send(node)
+          return unless flatten_join?(node.parent)
+
+          range = node.loc.dot.begin.join(node.source_range.end)
+          add_offense(range) do |corrector|
+            corrector.remove(range)
+          end
+        end
+        alias on_csend on_send
+      end
+    end
+  end
+end

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

@@ -54,12 +54,14 @@ module RuboCop
 
         private
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def check_branch(node)
           return unless node
 
           case node.type
-          when :case   then check_case_node(node)
-          when :if     then check_if_node(node)
+          when :case       then check_case_node(node)
+          when :case_match then check_case_match_node(node)
+          when :if         then check_if_node(node)
           when :rescue, :resbody
             check_rescue_node(node)
           when :ensure then check_ensure_node(node)
@@ -67,12 +69,18 @@ module RuboCop
             check_begin_node(node)
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def check_case_node(node)
           node.when_branches.each { |when_node| check_branch(when_node.body) }
           check_branch(node.else_branch)
         end
 
+        def check_case_match_node(node)
+          node.in_pattern_branches.each { |in_pattern_node| check_branch(in_pattern_node.body) }
+          check_branch(node.else_branch)
+        end
+
         def check_if_node(node)
           return if node.modifier_form? || node.ternary?
 
@@ -85,7 +93,7 @@ module RuboCop
         end
 
         def check_ensure_node(node)
-          check_branch(node.body)
+          check_branch(node.branch)
         end
 
         def check_begin_node(node)

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

@@ -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,7 +79,7 @@ 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
@@ -91,6 +95,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 +119,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 +141,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)
@@ -146,7 +159,7 @@ module RuboCop
         end
 
         def use_modifier_form_after_multiline_begin_block?(node)
-          return unless (parent = node.parent)
+          return false unless (parent = node.parent)
 
           node.multiline? && parent.if_type? && parent.modifier_form?
         end
@@ -173,7 +186,7 @@ module RuboCop
         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)

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,29 +42,45 @@ 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: ['nonzero?'] (default)
+      #   # good
+      #   num.nonzero? ? true : false
+      #
       class RedundantCondition < Base
+        include AllowedMethods
+        include CommentsHelp
         include RangeHelp
         extend AutoCorrector
 
         MSG = 'Use double pipes `||` instead.'
         REDUNDANT_CONDITION = 'This condition is not needed.'
+        ARGUMENT_WITH_OPERATOR_TYPES = %i[
+          splat block_pass forwarded_restarg forwarded_kwrestarg forwarded_args
+        ].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
 
@@ -66,16 +94,29 @@ 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.loc.expression unless node.ternary?
-          return node.loc.expression if node.ternary? && branches_have_method?(node)
+          return node.source_range unless node.ternary?
+          return node.source_range if node.ternary? && branches_have_method?(node)
 
           range_between(node.loc.question.begin_pos, node.loc.colon.end_pos)
         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? &&
@@ -91,7 +132,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)
@@ -99,7 +140,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
@@ -108,6 +149,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
@@ -126,8 +177,20 @@ module RuboCop
             !use_hash_key_access?(if_branch)
         end
 
+        # rubocop:disable 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
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
         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
 
@@ -137,26 +200,44 @@ 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)
         end
 
         def branches_have_method?(node)
-          _condition, if_branch, else_branch = *node
+          return false unless node.if_branch && node.else_branch
 
-          return false unless if_branch && 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)
-          node.send_type? && !node.method?(:[]) && node.arguments.one?
+          return false if !node.send_type? || node.method?(:[]) || !node.arguments.one?
+
+          !argument_with_operator?(node.first_argument)
         end
 
         def same_method?(if_branch, else_branch)
           if_branch.method?(else_branch.method_name) && if_branch.receiver == else_branch.receiver
         end
 
+        # If the argument is using an operator, it is an invalid syntax.
+        # e.g. `foo || *bar`, `foo || **bar`, and `foo || &bar`.
+        def argument_with_operator?(argument)
+          return true if ARGUMENT_WITH_OPERATOR_TYPES.include?(argument.type)
+          return false unless argument.hash_type?
+          return false unless (node = argument.children.first)
+
+          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 Metrics/AbcSize
         def if_source(if_branch, arithmetic_operation)
           if branches_have_method?(if_branch.parent) && if_branch.parenthesized?
             if_branch.source.delete_suffix(')')
@@ -164,10 +245,16 @@ 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?
+
+            wrap_arguments_with_parens(condition)
           else
             if_branch.source
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         def else_source(else_branch, arithmetic_operation) # rubocop:disable Metrics/AbcSize
           if arithmetic_operation
@@ -206,7 +293,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

@@ -63,26 +63,18 @@ module RuboCop
         RUBY
 
         def offense?(node)
-          return if node.modifier_form?
+          return false if node.modifier_form?
 
           redundant_condition?(node) || redundant_condition_inverted?(node)
         end
 
         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_current_directory_in_path.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for paths given to `require_relative` that start with
+      # the current directory (`./`), which can be omitted.
+      #
+      # @example
+      #
+      #   # bad
+      #   require_relative './path/to/feature'
+      #
+      #   # good
+      #   require_relative 'path/to/feature'
+      #
+      class RedundantCurrentDirectoryInPath < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Remove the redundant 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 (first_argument = node.first_argument)
+          return unless (index = first_argument.source.index(CURRENT_DIRECTORY_PREFIX))
+          return unless (redundant_length = redundant_path_length(first_argument.str_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
+
+        def redundant_path_length(path)
+          return unless (match = path&.match(REDUNDANT_CURRENT_DIRECTORY_PREFIX))
+
+          match[0].length
+        end
+      end
+    end
+  end
+end