rubocop 1.24.1 → 1.64.1

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for options hashes and discourages them if the
+      # Checks for options hashes and discourages them if the
       # current Ruby version supports keyword arguments.
       #
       # @example

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

@@ -3,12 +3,12 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for optional arguments to methods
+      # Checks for optional arguments to methods
       # that do not come at the end of the argument list.
       #
       # @safety
       #   This cop is unsafe because changing a method signature will
-      #   implicitly change behaviour.
+      #   implicitly change behavior.
       #
       # @example
       #   # bad

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

@@ -3,13 +3,13 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for places where keyword arguments can be used instead of
+      # Checks for places where keyword arguments can be used instead of
       # boolean arguments when defining methods. `respond_to_missing?` method is allowed by default.
       # These are customizable with `AllowedMethods` option.
       #
       # @safety
       #   This cop is unsafe because changing a method signature will
-      #   implicitly change behaviour.
+      #   implicitly change behavior.
       #
       # @example
       #   # bad
@@ -54,8 +54,9 @@ module RuboCop
         private
 
         def format_message(argument)
-          source = argument.source
-          format(MSG, original: source, replacement: source.sub(/\s+=/, ':'))
+          replacement = "#{argument.name}: #{argument.default_value.source}"
+
+          format(MSG, original: argument.source, replacement: replacement)
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for potential usage of the `||=` operator.
+      # Checks for potential usage of the `||=` operator.
       #
       # @example
       #   # bad

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

@@ -31,22 +31,26 @@ module RuboCop
         def on_masgn(node)
           lhs, rhs = *node
           lhs_elements = *lhs
+          rhs = rhs.body if rhs.rescue_type?
           rhs_elements = Array(rhs).compact # edge case for one constant
 
           return if allowed_lhs?(lhs) || allowed_rhs?(rhs) ||
                     allowed_masign?(lhs_elements, rhs_elements)
 
-          add_offense(node) { |corrector| autocorrect(corrector, node) }
+          range = node.source_range.begin.join(rhs.source_range.end)
+
+          add_offense(range) do |corrector|
+            autocorrect(corrector, node, lhs, rhs)
+          end
         end
 
         private
 
-        def autocorrect(corrector, node)
-          left, right = *node
-          left_elements = *left
-          right_elements = Array(right).compact
+        def autocorrect(corrector, node, lhs, rhs)
+          left_elements = *lhs
+          right_elements = Array(rhs).compact
           order = find_valid_order(left_elements, right_elements)
-          correction = assignment_corrector(node, order)
+          correction = assignment_corrector(node, rhs, order)
 
           corrector.replace(correction.correction_range, correction.correction)
         end
@@ -77,14 +81,19 @@ module RuboCop
           node.block_type? || node.send_type?
         end
 
-        def assignment_corrector(node, order)
-          _assignment, modifier = *node.parent
+        def assignment_corrector(node, rhs, order)
+          if node.parent&.rescue_type?
+            _assignment, modifier = *node.parent
+          else
+            _assignment, modifier = *rhs.parent
+          end
+
           if modifier_statement?(node.parent)
-            ModifierCorrector.new(node, config, order)
+            ModifierCorrector.new(node, rhs, modifier, config, order)
           elsif rescue_modifier?(modifier)
-            RescueCorrector.new(node, config, order)
+            RescueCorrector.new(node, rhs, modifier, config, order)
           else
-            GenericCorrector.new(node, config, order)
+            GenericCorrector.new(node, rhs, modifier, config, order)
           end
         end
 
@@ -133,8 +142,8 @@ module RuboCop
             @assignments = assignments
           end
 
-          def tsort_each_node(&block)
-            @assignments.each(&block)
+          def tsort_each_node(...)
+            @assignments.each(...)
           end
 
           def tsort_each_child(assignment)
@@ -172,17 +181,21 @@ module RuboCop
         end
 
         def modifier_statement?(node)
-          node && %i[if while until].include?(node.type) && node.modifier_form?
+          return false unless node
+
+          node.basic_conditional? && node.modifier_form?
         end
 
         # An internal class for correcting parallel assignment
         class GenericCorrector
           include Alignment
 
-          attr_reader :config, :node
+          attr_reader :node, :rhs, :rescue_result, :config
 
-          def initialize(node, config, new_elements)
+          def initialize(node, rhs, modifier, config, new_elements)
             @node = node
+            @rhs = rhs
+            _, _, @rescue_result = *modifier
             @config = config
             @new_elements = new_elements
           end
@@ -226,13 +239,10 @@ module RuboCop
         # protected by rescue
         class RescueCorrector < GenericCorrector
           def correction
-            _node, rescue_clause = *node.parent
-            _, _, rescue_result = *rescue_clause
-
             # If the parallel assignment uses a rescue modifier and it is the
             # only contents of a method, then we want to make use of the
             # implicit begin
-            if node.parent.parent&.def_type?
+            if rhs.parent.parent.parent&.def_type?
               super + def_correction(rescue_result)
             else
               begin_correction(rescue_result)
@@ -240,7 +250,7 @@ module RuboCop
           end
 
           def correction_range
-            node.parent.source_range
+            rhs.parent.parent.source_range
           end
 
           private
@@ -279,9 +289,7 @@ module RuboCop
           private
 
           def modifier_range(node)
-            Parser::Source::Range.new(node.source_range.source_buffer,
-                                      node.loc.keyword.begin_pos,
-                                      node.source_range.end_pos)
+            node.loc.keyword.join(node.source_range.end)
           end
         end
       end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for the presence of superfluous parentheses around the
+      # Checks for the presence of superfluous parentheses around the
       # condition of if/unless/while/until.
       #
       # `AllowSafeAssignment` option for safe assignment.
@@ -81,6 +81,7 @@ module RuboCop
           cond = node.condition
 
           control_op_condition(cond) do |first_child, rest_children|
+            return if require_parentheses?(node, first_child)
             return if semicolon_separated_expressions?(first_child, rest_children)
             return if modifier_op?(first_child)
             return if parens_allowed?(cond)
@@ -92,6 +93,13 @@ module RuboCop
           end
         end
 
+        def require_parentheses?(node, condition_body)
+          return false if !node.while_type? && !node.until_type?
+          return false if !condition_body.block_type? && !condition_body.numblock_type?
+
+          condition_body.send_node.block_literal? && condition_body.keywords?
+        end
+
         def semicolon_separated_expressions?(first_exp, rest_exps)
           return false unless (second_exp = rest_exps.first)
 

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop enforces the consistent usage of `%`-literal delimiters.
+      # Enforces the consistent usage of `%`-literal delimiters.
       #
       # Specify the 'default' key to set all preferred delimiters at once. You
       # can continue to specify individual preferred delimiters to override the
@@ -92,9 +92,8 @@ module RuboCop
 
         def contains_delimiter?(node, delimiters)
           delimiters_regexp = Regexp.union(delimiters)
-          node
-            .children.map { |n| string_source(n) }.compact
-            .any? { |s| delimiters_regexp.match?(s) }
+
+          node.children.filter_map { |n| string_source(n) }.any?(delimiters_regexp)
         end
 
         def string_source(node)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for usage of the %Q() syntax when %q() would do.
+      # Checks for usage of the %Q() syntax when %q() would do.
       #
       # @example EnforcedStyle: lower_case_q (default)
       #   # The `lower_case_q` style prefers `%q` unless
@@ -44,7 +44,7 @@ module RuboCop
 
           # Report offense only if changing case doesn't change semantics,
           # i.e., if the string would become dynamic or has special characters.
-          ast = ProcessedSource.new(corrected(node.source), target_ruby_version).ast
+          ast = parse(corrected(node.source)).ast
           return if node.children != ast.children
 
           add_offense(node.loc.begin) do |corrector|

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop looks for uses of Perl-style regexp match
+      # Looks for uses of Perl-style regexp match
       # backreferences and their English versions like
       # $1, $2, $&, &+, $MATCH, $PREMATCH, etc.
       #
@@ -83,10 +83,31 @@ module RuboCop
           end
         end
 
+        # @private
+        # @param [RuboCop::AST::Node] node
+        # @return [String, nil]
+        def preferred_expression_to_node_with_constant_prefix(node)
+          expression = preferred_expression_to(node)
+          return unless expression
+
+          "#{constant_prefix(node)}#{expression}"
+        end
+
+        # @private
+        # @param [RuboCop::AST::Node] node
+        # @return [String]
+        def constant_prefix(node)
+          if node.each_ancestor(:class, :module).any?
+            '::'
+          else
+            ''
+          end
+        end
+
         # @private
         # @param [RuboCop::AST::Node] node
         def on_back_ref_or_gvar_or_nth_ref(node)
-          preferred_expression = preferred_expression_to(node)
+          preferred_expression = preferred_expression_to_node_with_constant_prefix(node)
           return unless preferred_expression
 
           add_offense(

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for uses of methods `Hash#has_key?` and
+      # Checks for uses of methods `Hash#has_key?` and
       # `Hash#has_value?`, and suggests using `Hash#key?` and `Hash#value?` instead.
       #
       # It is configurable to enforce the verbose method names, by using the
@@ -61,7 +61,7 @@ module RuboCop
           if style == :verbose
             "has_#{method_name}"
           else
-            method_name.to_s.sub(/has_/, '')
+            method_name.to_s.delete_prefix('has_')
           end
         end
 

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for uses of Proc.new where Kernel#proc
+      # Checks for uses of Proc.new where Kernel#proc
       # would be more appropriate.
       #
       # @example
@@ -19,7 +19,8 @@ module RuboCop
         MSG = 'Use `proc` instead of `Proc.new`.'
 
         # @!method proc_new?(node)
-        def_node_matcher :proc_new?, '(block $(send (const {nil? cbase} :Proc) :new) ...)'
+        def_node_matcher :proc_new?,
+                         '({block numblock} $(send (const {nil? cbase} :Proc) :new) ...)'
 
         def on_block(node)
           proc_new?(node) do |block_method|
@@ -28,6 +29,8 @@ module RuboCop
             end
           end
         end
+
+        alias on_numblock on_block
       end
     end
   end

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

@@ -93,7 +93,7 @@ module RuboCop
                        end
 
           # The conversion process doubles escaped slashes, so they have to be reverted
-          correction.gsub('\\\\', '\\')
+          correction.gsub('\\\\', '\\').gsub('\"', '"')
         end
 
         def style
@@ -116,7 +116,7 @@ module RuboCop
         def wrong_quotes?(node)
           return super if hash_key?(node)
 
-          super(node.source[1..-1])
+          super(node.source[1..])
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks the args passed to `fail` and `raise`. For exploded
+      # Checks the args passed to `fail` and `raise`. For exploded
       # style (default), it recommends passing the exception class and message
       # to `raise`, rather than construct an instance of the error. It will
       # still allow passing just a message, or the construction of an error
@@ -16,6 +16,9 @@ module RuboCop
       # The exploded style has an `AllowedCompactTypes` configuration
       # option that takes an Array of exception name Strings.
       #
+      # @safety
+      #   This cop is unsafe because `raise Foo` calls `Foo.exception`, not `Foo.new`.
+      #
       # @example EnforcedStyle: exploded (default)
       #   # bad
       #   raise StandardError.new('message')
@@ -77,10 +80,10 @@ module RuboCop
 
         def correction_exploded_to_compact(node)
           exception_node, *message_nodes = *node.arguments
-          return node.source if message_nodes.size > 1
+          return if message_nodes.size > 1
 
           argument = message_nodes.first.source
-          exception_class = exception_node.const_name || exception_node.receiver.source
+          exception_class = exception_node.receiver&.source || exception_node.source
 
           if node.parent && requires_parens?(node.parent)
             "#{node.method_name}(#{exception_class}.new(#{argument}))"
@@ -91,6 +94,9 @@ module RuboCop
 
         def check_compact(node)
           if node.arguments.size > 1
+            exception = node.first_argument
+            return if exception.send_type? && exception.first_argument&.hash_type?
+
             add_offense(node, message: format(COMPACT_MSG, method: node.method_name)) do |corrector|
               replacement = correction_exploded_to_compact(node)
 
@@ -107,8 +113,7 @@ module RuboCop
 
           first_arg = node.first_argument
 
-          return unless first_arg.send_type? && first_arg.method?(:new)
-          return if acceptable_exploded_args?(first_arg.arguments)
+          return if !use_new_method?(first_arg) || acceptable_exploded_args?(first_arg.arguments)
 
           return if allowed_non_exploded_type?(first_arg)
 
@@ -120,6 +125,10 @@ module RuboCop
           end
         end
 
+        def use_new_method?(first_arg)
+          first_arg.send_type? && first_arg.receiver && first_arg.method?(:new)
+        end
+
         def acceptable_exploded_args?(args)
           # Allow code like `raise Ex.new(arg1, arg2)`.
           return true if args.size > 1

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for the use of randomly generated numbers,
+      # Checks for the use of randomly generated numbers,
       # added/subtracted with integer literals, as well as those with
       # Integer#succ and Integer#pred methods. Prefer using ranges instead,
       # as it clearly states the intentions.

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for a redundant argument passed to certain methods.
+      # Checks for a redundant argument passed to certain methods.
       #
       # NOTE: This cop is limited to methods with single parameter.
       #
@@ -13,6 +13,7 @@ module RuboCop
       # ----
       # Methods:
       #   join: ''
+      #   sum: 0
       #   split: ' '
       #   chomp: "\n"
       #   chomp!: "\n"
@@ -33,6 +34,9 @@ module RuboCop
       #   # bad
       #   array.join('')
       #   [1, 2, 3].join("")
+      #   array.sum(0)
+      #   exit(true)
+      #   exit!(false)
       #   string.split(" ")
       #   "first\nsecond".split(" ")
       #   string.chomp("\n")
@@ -42,6 +46,9 @@ module RuboCop
       #   # good
       #   array.join
       #   [1, 2, 3].join
+      #   array.sum
+      #   exit
+      #   exit!
       #   string.split
       #   "first second".split
       #   string.chomp
@@ -52,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
 
@@ -72,23 +81,46 @@ 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)
           if node.parenthesized?
             range_between(node.loc.begin.begin_pos, node.loc.end.end_pos)
           else
-            range_with_surrounding_space(range: node.first_argument.source_range, newlines: false)
+            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)
+          !target_argument.to_s.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_assignment.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for redundant assignment before returning.
+      # Checks for redundant assignment before returning.
       #
       # @example
       #   # bad
@@ -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?