rubocop 1.59.0 → 1.68.0

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_line_continuation.rb

@@ -69,16 +69,19 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Redundant line continuation.'
+        LINE_CONTINUATION = "\\\n"
+        LINE_CONTINUATION_PATTERN = /(\\\n)/.freeze
         ALLOWED_STRING_TOKENS = %i[tSTRING tSTRING_CONTENT].freeze
         ARGUMENT_TYPES = %i[
           kFALSE kNIL kSELF kTRUE tCONSTANT tCVAR tFLOAT tGVAR tIDENTIFIER tINTEGER tIVAR
           tLBRACK tLCURLY tLPAREN_ARG tSTRING tSTRING_BEG tSYMBOL tXSTRING_BEG
         ].freeze
+        ARGUMENT_TAKING_FLOW_TOKEN_TYPES = %i[tIDENTIFIER kRETURN kBREAK kNEXT kYIELD].freeze
 
         def on_new_investigation
           return unless processed_source.ast
 
-          each_match_range(processed_source.ast.source_range, /(\\\n)/) do |range|
+          each_match_range(processed_source.ast.source_range, LINE_CONTINUATION_PATTERN) do |range|
             next if require_line_continuation?(range)
             next unless redundant_line_continuation?(range)
 
@@ -86,6 +89,8 @@ module RuboCop
               corrector.remove_leading(range, 1)
             end
           end
+
+          inspect_eof_line_continuation
         end
 
         private
@@ -94,7 +99,8 @@ module RuboCop
           !ends_with_backslash_without_comment?(range.source_line) ||
             string_concatenation?(range.source_line) ||
             start_with_arithmetic_operator?(processed_source[range.line]) ||
-            inside_string_literal_or_method_with_argument?(range)
+            inside_string_literal_or_method_with_argument?(range) ||
+            leading_dot_method_chain_with_blank_line?(range)
         end
 
         def ends_with_backslash_without_comment?(source_line)
@@ -113,14 +119,34 @@ module RuboCop
           end
         end
 
+        def leading_dot_method_chain_with_blank_line?(range)
+          return false unless range.source_line.strip.start_with?('.', '&.')
+
+          processed_source[range.line].strip.empty?
+        end
+
         def redundant_line_continuation?(range)
-          return true unless (node = find_node_for_line(range.line))
+          return true unless (node = find_node_for_line(range.last_line))
           return false if argument_newline?(node)
 
-          source = node.parent ? node.parent.source : node.source
+          source = node.source
+          while (node = node.parent)
+            source = node.source
+          end
           parse(source.gsub("\\\n", "\n")).valid_syntax?
         end
 
+        def inspect_eof_line_continuation
+          return unless processed_source.raw_source.end_with?(LINE_CONTINUATION)
+
+          rindex = processed_source.raw_source.rindex(LINE_CONTINUATION)
+          line_continuation_range = range_between(rindex, rindex + 1)
+
+          add_offense(line_continuation_range) do |corrector|
+            corrector.remove_trailing(line_continuation_range, 1)
+          end
+        end
+
         def inside_string_literal?(range, token)
           ALLOWED_STRING_TOKENS.include?(token.type) && token.pos.overlaps?(range)
         end
@@ -130,10 +156,16 @@ module RuboCop
         #   do_something \
         #     argument
         def method_with_argument?(current_token, next_token)
-          current_token.type == :tIDENTIFIER && ARGUMENT_TYPES.include?(next_token.type)
+          return false unless ARGUMENT_TAKING_FLOW_TOKEN_TYPES.include?(current_token.type)
+
+          ARGUMENT_TYPES.include?(next_token.type)
         end
 
+        # rubocop:disable Metrics/AbcSize
         def argument_newline?(node)
+          node = node.to_a.last if node.assignment?
+          return false if node.parenthesized_call?
+
           node = node.children.first if node.root? && node.begin_type?
 
           if argument_is_method?(node)
@@ -144,10 +176,11 @@ module RuboCop
             node.loc.selector.line != node.first_argument.loc.line
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
-        def find_node_for_line(line)
+        def find_node_for_line(last_line)
           processed_source.ast.each_node do |node|
-            return node if same_line?(node, line)
+            return node if node.respond_to?(:expression) && node.expression&.last_line == last_line
           end
         end
 

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

@@ -31,9 +31,6 @@ module RuboCop
         # @!method allowed_pin_operator?(node)
         def_node_matcher :allowed_pin_operator?, '^(pin (begin !{lvar ivar cvar gvar}))'
 
-        # @!method arg_in_call_with_block?(node)
-        def_node_matcher :arg_in_call_with_block?, '^^(block (send _ _ equal?(%0) ...) ...)'
-
         def on_begin(node)
           return if !parentheses?(node) || parens_allowed?(node) || ignore_syntax?(node)
 
@@ -53,13 +50,12 @@ module RuboCop
         def ignore_syntax?(node)
           return false unless (parent = node.parent)
 
-          parent.while_post_type? || parent.until_post_type? ||
-            like_method_argument_parentheses?(parent)
+          parent.while_post_type? || parent.until_post_type? || parent.match_with_lvasgn_type? ||
+            like_method_argument_parentheses?(parent) || multiline_control_flow_statements?(node)
         end
 
         def allowed_expression?(node)
           allowed_ancestor?(node) ||
-            allowed_method_call?(node) ||
             allowed_multiple_expression?(node) ||
             allowed_ternary?(node) ||
             node.parent&.range_type?
@@ -70,11 +66,6 @@ module RuboCop
           keyword_ancestor?(node) && parens_required?(node)
         end
 
-        def allowed_method_call?(node)
-          # Don't flag `method (arg) { }`
-          arg_in_call_with_block?(node) && !parentheses?(node.parent)
-        end
-
         def allowed_multiple_expression?(node)
           return false if node.children.one?
 
@@ -104,6 +95,13 @@ module RuboCop
             !node.arithmetic_operation? && node.first_argument.begin_type?
         end
 
+        def multiline_control_flow_statements?(node)
+          return false unless (parent = node.parent)
+          return false if parent.single_line?
+
+          parent.return_type? || parent.next_type? || parent.break_type?
+        end
+
         def empty_parentheses?(node)
           # Don't flag `()`
           node.children.empty?
@@ -150,8 +148,10 @@ module RuboCop
           return if begin_node.chained?
 
           if node.and_type? || node.or_type?
+            return if node.semantic_operator? && begin_node.parent
+            return if node.multiline? && allow_in_multiline_conditions?
             return if ALLOWED_NODE_TYPES.include?(begin_node.parent&.type)
-            return if begin_node.parent&.if_type? && begin_node.parent&.ternary?
+            return if begin_node.parent&.if_type? && begin_node.parent.ternary?
 
             'a logical expression'
           elsif node.respond_to?(:comparison_method?) && node.comparison_method?
@@ -165,11 +165,19 @@ module RuboCop
         # @!method interpolation?(node)
         def_node_matcher :interpolation?, '[^begin ^^dstr]'
 
+        def allow_in_multiline_conditions?
+          parentheses_around_condition_config = config.for_cop('Style/ParenthesesAroundCondition')
+          return false unless parentheses_around_condition_config['Enabled']
+
+          !!parentheses_around_condition_config['AllowInMultilineConditions']
+        end
+
         def check_send(begin_node, node)
           return check_unary(begin_node, node) if node.unary_operation?
 
           return unless method_call_with_redundant_parentheses?(node)
-          return if call_chain_starts_with_int?(begin_node, node)
+          return if call_chain_starts_with_int?(begin_node, node) ||
+                    do_end_block_in_method_chain?(begin_node, node)
 
           offense(begin_node, 'a method call')
         end
@@ -269,6 +277,12 @@ module RuboCop
           recv&.int_type? && (parent = begin_node.parent) &&
             parent.send_type? && (parent.method?(:-@) || parent.method?(:+@))
         end
+
+        def do_end_block_in_method_chain?(begin_node, node)
+          return false unless (block = node.each_descendant(:block, :numblock).first)
+
+          block.keywords? && begin_node.each_ancestor(:send, :csend).any?
+        end
       end
     end
   end

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

@@ -53,7 +53,7 @@ module RuboCop
           return if interpolated_quotes?(node) || allowed_percent_q?(node)
 
           add_offense(node) do |corrector|
-            delimiter = /^%Q[^"]+$|'/.match?(node.source) ? QUOTE : SINGLE_QUOTE
+            delimiter = /\A%Q[^"]+\z|'/.match?(node.source) ? QUOTE : SINGLE_QUOTE
 
             corrector.replace(node.loc.begin, delimiter)
             corrector.replace(node.loc.end, delimiter)

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/redundant_return.rb

@@ -113,6 +113,7 @@ module RuboCop
           case node.type
           when :return then check_return_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 then check_rescue_node(node)
           when :resbody then check_resbody_node(node)
@@ -140,6 +141,11 @@ module RuboCop
           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.ternary?
 

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

@@ -103,7 +103,7 @@ module RuboCop
             next unless sibling.is_a?(AST::Node)
 
             sibling = sibling_node(sibling)
-            break unless sibling&.send_type? && sibling&.method?(node.method_name)
+            break unless sibling&.send_type? && sibling.method?(node.method_name)
             break unless sibling.arguments? && !sibling.receiver
             break unless in_same_section?(sibling, node)
             break unless node.first_argument.str_type? && sibling.first_argument.str_type?
@@ -131,7 +131,7 @@ module RuboCop
         end
 
         def in_same_section?(node1, node2)
-          !node1.source_range.with(end_pos: node2.source_range.end_pos).source.include?("\n\n")
+          !node1.source_range.join(node2.source_range.end).source.include?("\n\n")
         end
       end
     end

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

@@ -75,7 +75,7 @@ module RuboCop
 
           corrector.remove(range_between(operation.source_range.end_pos, node.source_range.end_pos))
           corrector.insert_before(operation, "begin\n#{node_indentation}")
-          corrector.insert_after(operation, <<~RESCUE_CLAUSE.chop)
+          corrector.insert_after(heredoc_end(operation) || operation, <<~RESCUE_CLAUSE.chop)
 
             #{node_offset}rescue
             #{node_indentation}#{rescue_args.source}
@@ -92,6 +92,18 @@ module RuboCop
           end
           [node_indentation, node_offset]
         end
+
+        def heredoc_end(node)
+          return unless node.call_type?
+
+          heredoc = node.arguments.reverse.find do |argument|
+            argument.respond_to?(:heredoc?) && argument.heredoc?
+          end
+
+          return unless heredoc
+
+          heredoc.loc.heredoc_end
+        end
       end
     end
   end

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

@@ -3,7 +3,8 @@
 module RuboCop
   module Cop
     module Style
-      # Checks if `return` or `return nil` is used in predicate method definitions.
+      # Checks for predicate method definitions that return `nil`.
+      # A predicate method should only return a boolean value.
       #
       # @safety
       #   Autocorrection is marked as unsafe because the change of the return value
@@ -31,6 +32,24 @@ module RuboCop
       #     do_something?
       #   end
       #
+      #   # bad
+      #   def foo?
+      #     if condition
+      #       nil
+      #     else
+      #       true
+      #     end
+      #   end
+      #
+      #   # good
+      #   def foo?
+      #     if condition
+      #       false
+      #     else
+      #       true
+      #     end
+      #   end
+      #
       # @example AllowedMethods: ['foo?']
       #   # good
       #   def foo?
@@ -64,24 +83,25 @@ module RuboCop
           return if allowed_method?(node.method_name) || matches_allowed_pattern?(node.method_name)
           return unless (body = node.body)
 
-          body.each_descendant(:return) do |return_node|
-            register_offense(return_node, 'return false') if return_nil?(return_node)
-          end
-
-          return unless (nil_node = nil_node_at_the_end_of_method_body(body))
+          body.each_descendant(:return) { |return_node| handle_return(return_node) }
 
-          register_offense(nil_node, 'false')
+          handle_implicit_return_values(body)
         end
         alias on_defs on_def
 
         private
 
-        def nil_node_at_the_end_of_method_body(body)
-          return body if body.nil_type?
-          return unless body.begin_type?
-          return unless (last_child = body.children.last)
+        def last_node_of_type(node, type)
+          return unless node
+          return node if node_type?(node, type)
+          return unless node.begin_type?
+          return unless (last_child = node.children.last)
+
+          last_child if last_child.is_a?(AST::Node) && node_type?(last_child, type)
+        end
 
-          last_child if last_child.is_a?(AST::Node) && last_child.nil_type?
+        def node_type?(node, type)
+          node.type == type.to_sym
         end
 
         def register_offense(offense_node, replacement)
@@ -89,6 +109,28 @@ module RuboCop
             corrector.replace(offense_node, replacement)
           end
         end
+
+        def handle_implicit_return_values(node)
+          handle_if(last_node_of_type(node, :if))
+          handle_nil(last_node_of_type(node, :nil))
+        end
+
+        def handle_return(return_node)
+          register_offense(return_node, 'return false') if return_nil?(return_node)
+        end
+
+        def handle_nil(nil_node)
+          return unless nil_node
+
+          register_offense(nil_node, 'false')
+        end
+
+        def handle_if(if_node)
+          return unless if_node
+
+          handle_implicit_return_values(if_node.if_branch)
+          handle_implicit_return_values(if_node.else_branch)
+        end
       end
     end
   end