rubocop 1.65.1 → 1.66.0

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

@@ -334,13 +334,18 @@ module RuboCop
           end
         end
 
+        # rubocop:disable Metrics/AbcSize
         def arguments_range(node, first_node)
-          arguments = node.arguments.reject { |arg| ADDITIONAL_ARG_TYPES.include?(arg.type) }
+          arguments = node.arguments.reject do |arg|
+            next true if ADDITIONAL_ARG_TYPES.include?(arg.type) || arg.variable? || arg.call_type?
 
-          start_node = first_node || arguments.first
+            arg.literal? && arg.each_descendant(:kwsplat).none?
+          end
 
-          range_between(start_node.source_range.begin_pos, arguments.last.source_range.end_pos)
+          start_node = first_node || arguments.first
+          start_node.source_range.begin.join(arguments.last.source_range.end)
         end
+        # rubocop:enable Metrics/AbcSize
 
         def allow_only_rest_arguments?
           cop_config.fetch('AllowOnlyRestArgument', true)

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

@@ -143,7 +143,7 @@ module RuboCop
         private
 
         def check(node)
-          return if cop_config['AllowComments'] && comment_in_else?(node.loc)
+          return if cop_config['AllowComments'] && comment_in_else?(node)
 
           empty_check(node) if empty_style?
           nil_check(node) if nil_style?
@@ -171,16 +171,16 @@ module RuboCop
 
         def autocorrect(corrector, node)
           return false if autocorrect_forbidden?(node.type.to_s)
-          return false if comment_in_else?(node.loc)
+          return false if comment_in_else?(node)
 
           end_pos = base_node(node).loc.end.begin_pos
           corrector.remove(range_between(node.loc.else.begin_pos, end_pos))
         end
 
-        def comment_in_else?(loc)
-          return false if loc.else.nil? || loc.end.nil?
+        def comment_in_else?(node)
+          node = node.parent while node.if_type? && node.elsif?
 
-          processed_source.contains_comment?(loc.else.join(loc.end))
+          processed_source.contains_comment?(node.loc.else.join(node.source_range.end))
         end
 
         def base_node(node)

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

@@ -36,6 +36,7 @@ module RuboCop
       class EmptyHeredoc < Base
         include Heredoc
         include RangeHelp
+        include StringLiteralsHelp
         extend AutoCorrector
 
         MSG = 'Use an empty string literal instead of heredoc.'
@@ -53,20 +54,6 @@ module RuboCop
             corrector.remove(range_by_whole_lines(heredoc_end, include_final_newline: true))
           end
         end
-
-        private
-
-        def preferred_string_literal
-          enforce_double_quotes? ? '""' : "''"
-        end
-
-        def enforce_double_quotes?
-          string_literals_config['EnforcedStyle'] == 'double_quotes'
-        end
-
-        def string_literals_config
-          config.for_cop('Style/StringLiterals')
-        end
       end
     end
   end

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

@@ -9,7 +9,9 @@ module RuboCop
       # @example
       #   # bad
       #   a = Array.new
+      #   a = Array[]
       #   h = Hash.new
+      #   h = Hash[]
       #   s = String.new
       #
       #   # good
@@ -19,19 +21,20 @@ module RuboCop
       class EmptyLiteral < Base
         include FrozenStringLiteral
         include RangeHelp
+        include StringLiteralsHelp
         extend AutoCorrector
 
-        ARR_MSG = 'Use array literal `[]` instead of `Array.new`.'
-        HASH_MSG = 'Use hash literal `{}` instead of `Hash.new`.'
+        ARR_MSG = 'Use array literal `[]` instead of `%<current>s`.'
+        HASH_MSG = 'Use hash literal `{}` instead of `%<current>s`.'
         STR_MSG = 'Use string literal `%<prefer>s` instead of `String.new`.'
 
-        RESTRICT_ON_SEND = %i[new].freeze
+        RESTRICT_ON_SEND = %i[new [] Array Hash].freeze
 
         # @!method array_node(node)
-        def_node_matcher :array_node, '(send (const {nil? cbase} :Array) :new)'
+        def_node_matcher :array_node, '(send (const {nil? cbase} :Array) :new (array)?)'
 
         # @!method hash_node(node)
-        def_node_matcher :hash_node, '(send (const {nil? cbase} :Hash) :new)'
+        def_node_matcher :hash_node, '(send (const {nil? cbase} :Hash) :new (array)?)'
 
         # @!method str_node(node)
         def_node_matcher :str_node, '(send (const {nil? cbase} :String) :new)'
@@ -47,6 +50,22 @@ module RuboCop
           }
         PATTERN
 
+        # @!method array_with_index(node)
+        def_node_matcher :array_with_index, <<~PATTERN
+          {
+            (send (const {nil? cbase} :Array) :[])
+            (send nil? :Array (array))
+          }
+        PATTERN
+
+        # @!method hash_with_index(node)
+        def_node_matcher :hash_with_index, <<~PATTERN
+          {
+            (send (const {nil? cbase} :Hash) :[])
+            (send nil? :Hash (array))
+          }
+        PATTERN
+
         def on_send(node)
           return unless (message = offense_message(node))
 
@@ -59,26 +78,14 @@ module RuboCop
 
         def offense_message(node)
           if offense_array_node?(node)
-            ARR_MSG
+            format(ARR_MSG, current: node.source)
           elsif offense_hash_node?(node)
-            HASH_MSG
+            format(HASH_MSG, current: node.source)
           elsif str_node(node) && !frozen_strings?
             format(STR_MSG, prefer: preferred_string_literal)
           end
         end
 
-        def preferred_string_literal
-          enforce_double_quotes? ? '""' : "''"
-        end
-
-        def enforce_double_quotes?
-          string_literals_config['EnforcedStyle'] == 'double_quotes'
-        end
-
-        def string_literals_config
-          config.for_cop('Style/StringLiterals')
-        end
-
         def first_argument_unparenthesized?(node)
           parent = node.parent
           return false unless parent && %i[send super zsuper].include?(parent.type)
@@ -100,12 +107,12 @@ module RuboCop
         end
 
         def offense_array_node?(node)
-          array_node(node) && !array_with_block(node.parent)
+          (array_node(node) && !array_with_block(node.parent)) || array_with_index(node)
         end
 
         def offense_hash_node?(node)
           # If Hash.new takes a block, it can't be changed to {}.
-          hash_node(node) && !hash_with_block(node.parent)
+          (hash_node(node) && !hash_with_block(node.parent)) || hash_with_index(node)
         end
 
         def correction(node)
@@ -129,8 +136,10 @@ module RuboCop
         def frozen_strings?
           return true if frozen_string_literals_enabled?
 
-          frozen_string_cop_enabled = config.for_cop('Style/FrozenStringLiteral')['Enabled']
-          frozen_string_cop_enabled && !frozen_string_literals_disabled?
+          frozen_string_cop_enabled = config.for_cop('Style/FrozenStringLiteralComment')['Enabled']
+          frozen_string_cop_enabled &&
+            !frozen_string_literals_disabled? &&
+            string_literals_frozen_by_default?.nil?
         end
       end
     end

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

@@ -11,8 +11,8 @@ module RuboCop
       # The reason is that _unannotated_ format is very similar
       # to encoded URLs or Date/Time formatting strings.
       #
-      # 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.
       #
       # @example EnforcedStyle: annotated (default)
       #

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

@@ -277,6 +277,8 @@ module RuboCop
         end
 
         def trivial?(node)
+          return false unless node.if_branch
+
           node.branches.one? && !node.if_branch.if_type? && !node.if_branch.begin_type?
         end
 

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

@@ -155,7 +155,7 @@ module RuboCop
           condition_variable = assignable_condition_value(node)
 
           head = heads.first
-          if head.assignment?
+          if head.respond_to?(:assignment?) && head.assignment?
             # The `send` node is used instead of the `indexasgn` node, so `name` cannot be used.
             # https://github.com/rubocop/rubocop-ast/blob/v1.29.0/lib/rubocop/ast/node/indexasgn_node.rb
             #

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,40 @@ 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)
+        def message(node)
+          template = if node.if_branch&.begin_type?
+                       MSG_NEWLINE
+                     elsif node.else_branch&.if_type? || node.else_branch&.begin_type?
+                       MSG_IF_ELSE
+                     else
+                       MSG_TERNARY
+                     end
+
+          format(template, expr: node.condition.source)
+        end
+
+        def autocorrect(corrector, node)
+          if node.if_branch&.begin_type? || node.else_branch&.begin_type?
+            corrector.replace(node.loc.begin, "\n")
+          else
+            corrector.replace(node, replacement(node))
+          end
+        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 +74,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/magic_comment_format.rb

@@ -105,21 +105,26 @@ module RuboCop
 
         # Value object to extract source ranges for the different parts of a magic comment
         class CommentRange
-          extend Forwardable
-
           DIRECTIVE_REGEXP = Regexp.union(MagicComment::KEYWORDS.map do |_, v|
             Regexp.new(v, Regexp::IGNORECASE)
           end).freeze
 
           VALUE_REGEXP = Regexp.new("(?:#{DIRECTIVE_REGEXP}:\s*)(.*?)(?=;|$)")
 
-          def_delegators :@comment, :text, :loc
           attr_reader :comment
 
           def initialize(comment)
             @comment = comment
           end
 
+          def text
+            @comment.text
+          end
+
+          def loc
+            @comment.loc
+          end
+
           # A magic comment can contain one directive (normal style) or
           # multiple directives (emacs style)
           def directives

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)'

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/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

@@ -39,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)
 
@@ -57,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/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/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