rubocop 1.65.0 → 1.66.1

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

@@ -44,7 +44,6 @@ module RuboCop
       #   # good
       #   foo == bar
       #
-      # @example
       #   # bad
       #   if foo.do_something?
       #     true

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

@@ -18,6 +18,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG_IF_ELSE = 'Do not use `if %<expr>s;` - use `if/else` instead.'
+        MSG_NEWLINE = 'Do not use `if %<expr>s;` - use a newline instead.'
         MSG_TERNARY = 'Do not use `if %<expr>s;` - use a ternary operator instead.'
 
         def on_normal_if_unless(node)
@@ -26,20 +27,47 @@ module RuboCop
           beginning = node.loc.begin
           return unless beginning&.is?(';')
 
-          message = node.else_branch&.if_type? ? MSG_IF_ELSE : MSG_TERNARY
+          message = message(node)
 
-          add_offense(node, message: format(message, expr: node.condition.source)) do |corrector|
-            corrector.replace(node, autocorrect(node))
+          add_offense(node, message: message) do |corrector|
+            autocorrect(corrector, node)
           end
         end
 
         private
 
-        def autocorrect(node)
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def message(node)
+          template = if node.if_branch&.begin_type?
+                       MSG_NEWLINE
+                     elsif node.else_branch&.if_type? || node.else_branch&.begin_type? ||
+                           use_block_in_branches?(node)
+                       MSG_IF_ELSE
+                     else
+                       MSG_TERNARY
+                     end
+
+          format(template, expr: node.condition.source)
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        def autocorrect(corrector, node)
+          if node.branches.compact.any?(&:begin_type?) || use_block_in_branches?(node)
+            corrector.replace(node.loc.begin, "\n")
+          else
+            corrector.replace(node, replacement(node))
+          end
+        end
+
+        def use_block_in_branches?(node)
+          node.branches.compact.any? { |branch| branch.block_type? || branch.numblock_type? }
+        end
+
+        def replacement(node)
           return correct_elsif(node) if node.else_branch&.if_type?
 
-          then_code = node.if_branch ? node.if_branch.source : 'nil'
-          else_code = node.else_branch ? node.else_branch.source : 'nil'
+          then_code = node.if_branch ? build_expression(node.if_branch) : 'nil'
+          else_code = node.else_branch ? build_expression(node.else_branch) : 'nil'
 
           "#{node.condition.source} ? #{then_code} : #{else_code}"
         end
@@ -53,6 +81,17 @@ module RuboCop
           RUBY
         end
 
+        # rubocop:disable Metrics/AbcSize
+        def build_expression(expr)
+          return expr.source if !expr.call_type? || expr.parenthesized? || expr.arguments.empty?
+
+          method = expr.source_range.begin.join(expr.loc.selector.end)
+          arguments = expr.first_argument.source_range.begin.join(expr.source_range.end)
+
+          "#{method.source}(#{arguments.source})"
+        end
+        # rubocop:enable Metrics/AbcSize
+
         def build_else_branch(second_condition)
           result = <<~RUBY
             elsif #{second_condition.condition.source}

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

@@ -44,11 +44,15 @@ module RuboCop
         private
 
         def alternative_pattern_source(pattern)
+          collect_alternative_patterns(pattern).join(' | ')
+        end
+
+        def collect_alternative_patterns(pattern)
           return pattern.children.map(&:source) unless pattern.children.first.match_alt_type?
 
-          pattern_sources = alternative_pattern_source(pattern.children.first)
+          pattern_sources = collect_alternative_patterns(pattern.children.first)
 
-          (pattern_sources << pattern.children[1].source).join(' | ')
+          pattern_sources << pattern.children[1].source
         end
       end
     end

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

@@ -72,8 +72,8 @@ module RuboCop
 
         private
 
-        def invertible?(node)
-          case node.type
+        def invertible?(node) # rubocop:disable Metrics/CyclomaticComplexity
+          case node&.type
           when :begin
             invertible?(node.children.first)
           when :send

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

@@ -105,7 +105,7 @@ module RuboCop
 
         # Value object to extract source ranges for the different parts of a magic comment
         class CommentRange
-          extend Forwardable
+          extend SimpleForwardable
 
           DIRECTIVE_REGEXP = Regexp.union(MagicComment::KEYWORDS.map do |_, v|
             Regexp.new(v, Regexp::IGNORECASE)

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

@@ -58,12 +58,21 @@ module RuboCop
           [
             ^({begin kwbegin} ...)
             ({block numblock} (send !{nil? self} :each) _
-              (send (lvar _) {:<< :push :append} _))
+              (send (lvar _) {:<< :push :append} {send lvar begin}))
           ]
         PATTERN
 
         # @!method empty_array_asgn?(node)
-        def_node_matcher :empty_array_asgn?, '(lvasgn _ (array))'
+        def_node_matcher :empty_array_asgn?, <<~PATTERN
+          (
+            lvasgn _ {
+              (array)
+              (send (const {nil? cbase} :Array) :[])
+              (send (const {nil? cbase} :Array) :new (array)?)
+              (send nil? :Array (array))
+            }
+          )
+        PATTERN
 
         # @!method lvar_ref?(node, name)
         def_node_matcher :lvar_ref?, '(lvar %1)'
@@ -138,10 +147,8 @@ module RuboCop
             false
           when :begin, :kwbegin
             !node.right_sibling && return_value_used?(parent)
-          when :block, :numblock
-            !parent.void_context?
           else
-            true
+            !parent.respond_to?(:void_context?) || !parent.void_context?
           end
         end
 

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

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Style
       # Enforces the presence (default) or absence of parentheses in
-      # method calls containing parameters.
+      # method calls containing arguments.
       #
       # In the default style (require_parentheses), macro methods are allowed.
       # Additional methods can be added to the `AllowedMethods` or

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

@@ -5,8 +5,8 @@ module RuboCop
     module Style
       # Checks for unwanted parentheses in parameterless method calls.
       #
-      # This cop can be customized allowed methods with `AllowedMethods`.
-      # By default, there are no methods to allowed.
+      # This cop's allowed methods can be customized with `AllowedMethods`.
+      # By default, there are no allowed methods.
       #
       # NOTE: This cop allows the use of `it()` without arguments in blocks,
       # as in `0.times { it() }`, following `Lint/ItWithoutArgumentsInBlock` cop.

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

@@ -168,10 +168,6 @@ module RuboCop
           config.for_cop('Style/UnlessElse')
         end
 
-        def empty_else_cop_enabled?
-          empty_else_config.fetch('Enabled')
-        end
-
         def empty_else_style
           return unless empty_else_config.key?('EnforcedStyle')
 

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

@@ -54,10 +54,6 @@ module RuboCop
 
           same_line?(when_node, when_node.body)
         end
-
-        def accept_node_type?(node)
-          node&.array_type? || node&.hash_type?
-        end
       end
     end
   end

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

@@ -56,12 +56,10 @@ module RuboCop
               'in a conditional, use `Array#include?` instead.'
 
         def on_new_investigation
-          @last_comparison = nil
+          reset_comparison
         end
 
         def on_or(node)
-          reset_comparison if switch_comparison?(node)
-
           root_of_or_node = root_of_or_node(node)
 
           return unless node == root_of_or_node
@@ -74,9 +72,9 @@ module RuboCop
             prefer_method = "[#{elements}].include?(#{variables_in_node(node).first})"
 
             corrector.replace(node, prefer_method)
-          end
 
-          @last_comparison = node
+            reset_comparison
+          end
         end
 
         private
@@ -147,12 +145,6 @@ module RuboCop
           end
         end
 
-        def switch_comparison?(node)
-          return true if @last_comparison.nil?
-
-          @last_comparison.descendants.none?(node)
-        end
-
         def reset_comparison
           @compared_elements = []
           @allowed_method_comparison = false

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

@@ -8,8 +8,8 @@ module RuboCop
       # These can be replaced by their respective predicate methods.
       # This cop can also be configured to do the reverse.
       #
-      # This cop can be customized allowed methods with `AllowedMethods`.
-      # By default, there are no methods to allowed.
+      # This cop's allowed methods can be customized with `AllowedMethods`.
+      # By default, there are no allowed methods.
       #
       # This cop disregards `#nonzero?` as its value is truthy or falsey,
       # but not `true` and `false`, and thus not always interchangeable with

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

@@ -42,7 +42,7 @@ module RuboCop
         def on_normal_if_unless(node)
           return unless node.single_line?
           return unless node.else_branch
-          return if node.elsif?
+          return if node.elsif? || node.if_branch&.begin_type?
 
           message = message(node)
           add_offense(node, message: message) do |corrector|

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

@@ -211,15 +211,16 @@ module RuboCop
           protected
 
           def assignment
-            @new_elements.map { |lhs, rhs| "#{lhs.source} = #{source(rhs)}" }
+            @new_elements.map { |lhs, rhs| "#{lhs.source} = #{source(rhs, rhs.loc)}" }
           end
 
           private
 
-          def source(node)
-            if node.str_type? && node.loc.begin.nil?
+          def source(node, loc)
+            # __FILE__ is treated as a StrNode but has no begin
+            if node.str_type? && loc.respond_to?(:begin) && loc.begin.nil?
               "'#{node.source}'"
-            elsif node.sym_type? && node.loc.begin.nil?
+            elsif node.sym_type? && loc.begin.nil?
               ":#{node.source}"
             else
               node.source

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

@@ -98,8 +98,6 @@ module RuboCop
 
         def style
           return super unless super == :same_as_string_literals
-
-          string_literals_config = config.for_cop('Style/StringLiterals')
           return :single_quotes unless string_literals_config['Enabled']
 
           string_literals_config['EnforcedStyle'].to_sym

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

@@ -12,7 +12,6 @@ module RuboCop
       #   # good
       #   a = b || c
       #
-      # @example
       #   # bad
       #   if b
       #     b
@@ -40,9 +39,9 @@ module RuboCop
           splat block_pass forwarded_restarg forwarded_kwrestarg forwarded_args
         ].freeze
 
+        # rubocop:disable Metrics/AbcSize
         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)
 
@@ -58,6 +57,7 @@ module RuboCop
             end
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         private
 

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Before Ruby 3.0, interpolated strings followed the frozen string literal
+      # magic comment which sometimes made it necessary to explicitly unfreeze them.
+      # Ruby 3.0 changed interpolated strings to always be unfrozen which makes
+      # unfreezing them redundant.
+      #
+      # @example
+      #   # bad
+      #   +"#{foo} bar"
+      #
+      #   # bad
+      #   "#{foo} bar".dup
+      #
+      #   # good
+      #   "#{foo} bar"
+      #
+      class RedundantInterpolationUnfreeze < Base
+        include FrozenStringLiteral
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        MSG = "Don't unfreeze interpolated strings as they are already unfrozen."
+
+        RESTRICT_ON_SEND = %i[+@ dup].freeze
+
+        minimum_target_ruby_version 3.0
+
+        def on_send(node)
+          return if node.arguments?
+          return unless (receiver = node.receiver)
+          return unless receiver.dstr_type?
+          return if uninterpolated_string?(receiver) || uninterpolated_heredoc?(receiver)
+
+          add_offense(node.loc.selector) do |corrector|
+            corrector.remove(node.loc.selector)
+            corrector.remove(node.loc.dot) unless node.unary_operation?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -33,6 +33,7 @@ module RuboCop
       #   'foo'.sub('f', 'x')
       #   'foo'.sub!('f', 'x')
       class RedundantRegexpArgument < Base
+        include StringLiteralsHelp
         extend AutoCorrector
 
         MSG = 'Use string `%<prefer>s` as argument instead of regexp `%<current>s`.'
@@ -71,8 +72,10 @@ module RuboCop
           if new_argument.include?('"')
             new_argument.gsub!("'", "\\\\'")
             quote = "'"
-          else
+          elsif new_argument.include?('\\')
             quote = '"'
+          else
+            quote = enforce_double_quotes? ? '"' : "'"
           end
 
           "#{quote}#{new_argument}#{quote}"

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

@@ -95,30 +95,14 @@ module RuboCop
           delimiters.include?(char)
         end
 
-        if Gem::Version.new(Regexp::Parser::VERSION) >= Gem::Version.new('2.0')
-          def each_escape(node)
-            node.parsed_tree&.traverse&.reduce(0) do |char_class_depth, (event, expr)|
-              yield(expr.text[1], expr.ts, !char_class_depth.zero?) if expr.type == :escape
-
-              if expr.type == :set
-                char_class_depth + (event == :enter ? 1 : -1)
-              else
-                char_class_depth
-              end
-            end
-          end
-        # Please remove this `else` branch when support for regexp_parser 1.8 will be dropped.
-        # It's for compatibility with regexp_parser 1.8 and will never be maintained.
-        else
-          def each_escape(node)
-            node.parsed_tree&.traverse&.reduce(0) do |char_class_depth, (event, expr)|
-              yield(expr.text[1], expr.start_index, !char_class_depth.zero?) if expr.type == :escape
-
-              if expr.type == :set
-                char_class_depth + (event == :enter ? 1 : -1)
-              else
-                char_class_depth
-              end
+        def each_escape(node)
+          node.parsed_tree&.traverse&.reduce(0) do |char_class_depth, (event, expr)|
+            yield(expr.text[1], expr.ts, !char_class_depth.zero?) if expr.type == :escape
+
+            if expr.type == :set
+              char_class_depth + (event == :enter ? 1 : -1)
+            else
+              char_class_depth
             end
           end
         end

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

@@ -17,9 +17,9 @@ module RuboCop
       # `foo&.bar` can start returning `nil` as well as what the method
       # returns.
       #
-      # The default for `MaxChainLength` is `2`
+      # The default for `MaxChainLength` is `2`.
       # We have limited the cop to not register an offense for method chains
-      # that exceed this option is set.
+      # that exceed this option's value.
       #
       # @safety
       #   Autocorrection is unsafe because if a value is `false`, the resulting

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

@@ -159,7 +159,13 @@ module RuboCop
           node_to_check = condition&.block_type? ? condition.send_node : condition
           return unless wrap_condition?(node_to_check)
 
-          corrector.wrap(condition, '(', ')')
+          if condition.call_type?
+            source = parenthesized_method_arguments(condition)
+
+            corrector.replace(condition, source)
+          else
+            corrector.wrap(condition, '(', ')')
+          end
         end
 
         def correct_for_outer_condition_modify_form_style(corrector, node, if_branch)
@@ -236,7 +242,20 @@ module RuboCop
         end
 
         def replace_condition(condition)
-          wrap_condition?(condition) ? "(#{condition.source})" : condition.source
+          return condition.source unless wrap_condition?(condition)
+
+          if condition.call_type?
+            parenthesized_method_arguments(condition)
+          else
+            "(#{condition.source})"
+          end
+        end
+
+        def parenthesized_method_arguments(node)
+          method_call = node.source_range.begin.join(node.loc.selector.end).source
+          arguments = node.first_argument.source_range.begin.join(node.source_range.end).source
+
+          "#{method_call}(#{arguments})"
         end
 
         def allow_modifier?

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

@@ -17,8 +17,6 @@ module RuboCop
       #     do_something(x.pop)
       #   end
       #
-      # @example
-      #
       #   # bad
       #   until x.empty? do
       #     do_something(x.pop)

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

@@ -16,7 +16,6 @@ module RuboCop
       #   # good
       #   x += 1 while x < 10
       #
-      # @example
       #   # bad
       #   until x > 10
       #     x += 1

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

@@ -47,7 +47,11 @@ module RuboCop
           check_zero_length_comparison(node)
           check_nonzero_length_comparison(node)
         end
-        alias on_csend on_send
+
+        def on_csend(node)
+          check_zero_length_predicate(node)
+          check_zero_length_comparison(node)
+        end
 
         private
 

data/lib/rubocop/cop/team.rb

@@ -120,8 +120,12 @@ module RuboCop
       end
 
       def external_dependency_checksum
-        keys = cops.filter_map(&:external_dependency_checksum)
-        Digest::SHA1.hexdigest(keys.join)
+        # The external dependency checksums are cached per RuboCop team so that
+        # the checksums don't need to be recomputed for each file.
+        @external_dependency_checksum ||= begin
+          keys = cops.filter_map(&:external_dependency_checksum)
+          Digest::SHA1.hexdigest(keys.join)
+        end
       end
 
       private

data/lib/rubocop/cop/variable_force.rb

@@ -27,7 +27,10 @@ module RuboCop
     class VariableForce < Force # rubocop:disable Metrics/ClassLength
       VARIABLE_ASSIGNMENT_TYPE = :lvasgn
       REGEXP_NAMED_CAPTURE_TYPE = :match_with_lvasgn
-      VARIABLE_ASSIGNMENT_TYPES = [VARIABLE_ASSIGNMENT_TYPE, REGEXP_NAMED_CAPTURE_TYPE].freeze
+      PATTERN_MATCH_VARIABLE_TYPE = :match_var
+      VARIABLE_ASSIGNMENT_TYPES = [
+        VARIABLE_ASSIGNMENT_TYPE, REGEXP_NAMED_CAPTURE_TYPE, PATTERN_MATCH_VARIABLE_TYPE
+      ].freeze
 
       ARGUMENT_DECLARATION_TYPES = [
         :arg, :optarg, :restarg,
@@ -112,6 +115,7 @@ module RuboCop
       NODE_HANDLER_METHOD_NAMES = [
         [VARIABLE_ASSIGNMENT_TYPE, :process_variable_assignment],
         [REGEXP_NAMED_CAPTURE_TYPE, :process_regexp_named_captures],
+        [PATTERN_MATCH_VARIABLE_TYPE, :process_pattern_match_variable],
         [MULTIPLE_ASSIGNMENT_TYPE, :process_variable_multiple_assignment],
         [VARIABLE_REFERENCE_TYPE, :process_variable_referencing],
         [RESCUE_TYPE, :process_rescue],
@@ -175,6 +179,14 @@ module RuboCop
         skip_children!
       end
 
+      def process_pattern_match_variable(node)
+        name = node.children.first
+
+        variable_table.declare_variable(name, node) unless variable_table.variable_exist?(name)
+
+        skip_children!
+      end
+
       def regexp_captured_names(node)
         regexp = node.to_regexp
 

data/lib/rubocop/core_ext/string.rb

@@ -9,12 +9,8 @@ class String
     # @return [Boolean] true is the string is blank, false otherwise
     #
     # @example
-    #   ''.blank? #=> true
-    #
-    # @example
-    #   '    '.blank? #=> true
-    #
-    # @example
+    #   ''.blank?       #=> true
+    #   '    '.blank?   #=> true
     #   '  test'.blank? #=> false
     def blank?
       empty? || lstrip.empty?

data/lib/rubocop/ext/regexp_node.rb

@@ -15,39 +15,17 @@ module RuboCop
       # see `ext/regexp_parser`.
       attr_reader :parsed_tree
 
-      if Gem::Version.new(Regexp::Parser::VERSION) >= Gem::Version.new('2.0')
-        def assign_properties(*)
-          super
+      def assign_properties(*)
+        super
 
-          str = with_interpolations_blanked
-          @parsed_tree = begin
-            Regexp::Parser.parse(str, options: options)
-          rescue StandardError
-            nil
-          end
-          origin = loc.begin.end
-          @parsed_tree&.each_expression(true) { |e| e.origin = origin }
-        end
-      # Please remove this `else` branch when support for regexp_parser 1.8 will be dropped.
-      # It's for compatibility with regexp_parser 1.8 and will never be maintained.
-      else
-        def assign_properties(*)
-          super
-
-          str = with_interpolations_blanked
-          begin
-            @parsed_tree = Regexp::Parser.parse(str, options: options)
-          rescue StandardError
-            @parsed_tree = nil
-          else
-            origin = loc.begin.end
-            source = @parsed_tree.to_s
-            @parsed_tree.each_expression(true) do |e|
-              e.origin = origin
-              e.source = source
-            end
-          end
+        str = with_interpolations_blanked
+        @parsed_tree = begin
+          Regexp::Parser.parse(str, options: options)
+        rescue StandardError
+          nil
         end
+        origin = loc.begin.end
+        @parsed_tree&.each_expression(true) { |e| e.origin = origin }
       end
 
       def each_capture(named: ANY)