rubocop 1.42.0 → 1.64.1

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

@@ -17,12 +17,11 @@ module RuboCop
         include Parentheses
         extend AutoCorrector
 
+        ALLOWED_NODE_TYPES = %i[and or send splat kwsplat].freeze
+
         # @!method square_brackets?(node)
         def_node_matcher :square_brackets?, '(send {(send _recv _msg) str array hash} :[] ...)'
 
-        # @!method range_end?(node)
-        def_node_matcher :range_end?, '^^{irange erange}'
-
         # @!method method_node_and_args(node)
         def_node_matcher :method_node_and_args, '$(call _recv _msg $...)'
 
@@ -54,15 +53,16 @@ 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)
+            allowed_ternary?(node) ||
+            node.parent&.range_type?
         end
 
         def allowed_ancestor?(node)
@@ -85,7 +85,7 @@ module RuboCop
         end
 
         def allowed_ternary?(node)
-          return unless node&.parent&.if_type?
+          return false unless node&.parent&.if_type?
 
           node.parent.ternary? && ternary_parentheses_required?
         end
@@ -98,10 +98,19 @@ module RuboCop
         end
 
         def like_method_argument_parentheses?(node)
-          node.send_type? && node.arguments.one? &&
+          return false if !node.send_type? && !node.super_type? && !node.yield_type?
+
+          node.arguments.one? && !node.parenthesized? &&
             !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?
@@ -109,34 +118,69 @@ module RuboCop
 
         def first_arg_begins_with_hash_literal?(node)
           # Don't flag `method ({key: value})` or `method ({key: value}.method)`
-          method_chain_begins_with_hash_literal?(node.children.first) &&
-            first_argument?(node) &&
-            !parentheses?(node.parent)
+          hash_literal = method_chain_begins_with_hash_literal(node.children.first)
+          if (root_method = node.each_ancestor(:send).to_a.last)
+            parenthesized = root_method.parenthesized_call?
+          end
+          hash_literal && first_argument?(node) && !parentheses?(hash_literal) && !parenthesized
         end
 
-        def method_chain_begins_with_hash_literal?(node)
-          return false if node.nil?
-          return true if node.hash_type?
-          return false unless node.send_type?
+        def method_chain_begins_with_hash_literal(node)
+          return if node.nil?
+          return node if node.hash_type?
+          return unless node.send_type?
 
-          method_chain_begins_with_hash_literal?(node.children.first)
+          method_chain_begins_with_hash_literal(node.children.first)
         end
 
         def check(begin_node)
           node = begin_node.children.first
-          return offense(begin_node, 'a keyword') if keyword_with_redundant_parentheses?(node)
-          return offense(begin_node, 'a literal') if disallowed_literal?(begin_node, node)
-          return offense(begin_node, 'a variable') if node.variable?
-          return offense(begin_node, 'a constant') if node.const_type?
 
-          return offense(begin_node, 'an interpolated expression') if interpolation?(begin_node)
+          if (message = find_offense_message(begin_node, node))
+            return offense(begin_node, message)
+          end
 
           check_send(begin_node, node) if node.call_type?
         end
 
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        def find_offense_message(begin_node, node)
+          return 'a keyword' if keyword_with_redundant_parentheses?(node)
+          return 'a literal' if disallowed_literal?(begin_node, node)
+          return 'a variable' if node.variable?
+          return 'a constant' if node.const_type?
+          if node.lambda_or_proc? && (node.braces? || node.send_node.lambda_literal?)
+            return 'an expression'
+          end
+          return 'an interpolated expression' if interpolation?(begin_node)
+
+          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?
+
+            'a logical expression'
+          elsif node.respond_to?(:comparison_method?) && node.comparison_method?
+            return unless begin_node.parent.nil?
+
+            'a comparison expression'
+          end
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+
         # @!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?
 
@@ -153,7 +197,7 @@ module RuboCop
 
           return if node.send_type? && !method_call_with_redundant_parentheses?(node)
 
-          offense(begin_node, 'an unary operation')
+          offense(begin_node, 'a unary operation')
         end
 
         def offense(node, msg)
@@ -201,7 +245,6 @@ module RuboCop
         def method_call_with_redundant_parentheses?(node)
           return false unless node.call_type?
           return false if node.prefix_not?
-          return false if range_end?(node)
 
           send_node, args = method_node_and_args(node)
 
@@ -213,7 +256,13 @@ module RuboCop
         end
 
         def first_argument?(node)
-          first_send_argument?(node) || first_super_argument?(node) || first_yield_argument?(node)
+          if first_send_argument?(node) ||
+             first_super_argument?(node) ||
+             first_yield_argument?(node)
+            return true
+          end
+
+          node.each_ancestor.any? { |ancestor| first_argument?(ancestor) }
         end
 
         # @!method first_send_argument?(node)

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)
@@ -93,7 +93,7 @@ module RuboCop
 
           return true if STRING_INTERPOLATION_REGEXP.match?(src)
 
-          src.scan(/\\./).any? { |s| ESCAPED_NON_BACKSLASH.match?(s) }
+          src.scan(/\\./).any?(ESCAPED_NON_BACKSLASH)
         end
 
         def acceptable_capital_q?(node)

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Identifies places where argument can be replaced from
+      # a deterministic regexp to a string.
+      #
+      # @example
+      #   # bad
+      #   'foo'.byteindex(/f/)
+      #   'foo'.byterindex(/f/)
+      #   'foo'.gsub(/f/, 'x')
+      #   'foo'.gsub!(/f/, 'x')
+      #   'foo'.partition(/f/)
+      #   'foo'.rpartition(/f/)
+      #   'foo'.scan(/f/)
+      #   'foo'.split(/f/)
+      #   'foo'.start_with?(/f/)
+      #   'foo'.sub(/f/, 'x')
+      #   'foo'.sub!(/f/, 'x')
+      #
+      #   # good
+      #   'foo'.byteindex('f')
+      #   'foo'.byterindex('f')
+      #   'foo'.gsub('f', 'x')
+      #   'foo'.gsub!('f', 'x')
+      #   'foo'.partition('f')
+      #   'foo'.rpartition('f')
+      #   'foo'.scan('f')
+      #   'foo'.split('f')
+      #   'foo'.start_with?('f')
+      #   'foo'.sub('f', 'x')
+      #   'foo'.sub!('f', 'x')
+      class RedundantRegexpArgument < Base
+        extend AutoCorrector
+
+        MSG = 'Use string `%<prefer>s` as argument instead of regexp `%<current>s`.'
+        RESTRICT_ON_SEND = %i[
+          byteindex byterindex gsub gsub! partition rpartition scan split start_with? sub sub!
+        ].freeze
+        DETERMINISTIC_REGEX = /\A(?:#{LITERAL_REGEX})+\Z/.freeze
+        STR_SPECIAL_CHARS = %w[
+          \a \c \C \e \f \M \n \" \' \\\\ \t \b \f \r \u \v \x \0 \1 \2 \3 \4 \5 \6 \7
+        ].freeze
+
+        def on_send(node)
+          return unless (regexp_node = node.first_argument)
+          return unless regexp_node.regexp_type?
+          return if !regexp_node.regopt.children.empty? || regexp_node.content == ' '
+          return unless determinist_regexp?(regexp_node)
+
+          prefer = preferred_argument(regexp_node)
+          message = format(MSG, prefer: prefer, current: regexp_node.source)
+
+          add_offense(regexp_node, message: message) do |corrector|
+            corrector.replace(regexp_node, prefer)
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def determinist_regexp?(regexp_node)
+          DETERMINISTIC_REGEX.match?(regexp_node.source)
+        end
+
+        def preferred_argument(regexp_node)
+          new_argument = replacement(regexp_node)
+
+          if new_argument.include?('"')
+            new_argument.gsub!("'", "\\\\'")
+            quote = "'"
+          else
+            quote = '"'
+          end
+
+          "#{quote}#{new_argument}#{quote}"
+        end
+
+        def replacement(regexp_node)
+          regexp_content = regexp_node.content
+          stack = []
+          chars = regexp_content.chars.each_with_object([]) do |char, strings|
+            if stack.empty? && char == '\\'
+              stack.push(char)
+            else
+              strings << "#{stack.pop}#{char}"
+            end
+          end
+          chars.map do |char|
+            char = char.dup
+            char.delete!('\\') unless STR_SPECIAL_CHARS.include?(char)
+            char
+          end.join
+        end
+      end
+    end
+  end
+end

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

@@ -63,7 +63,7 @@ module RuboCop
             next if expr.type != :set || expr.expressions.size != 1
             next if expr.negative?
             next if %i[set posixclass nonposixclass].include?(expr.expressions.first.type)
-            next if multiple_codepoins?(expr.expressions.first)
+            next if multiple_codepoints?(expr.expressions.first)
 
             yield expr
           end
@@ -74,13 +74,13 @@ module RuboCop
 
           non_redundant =
             whitespace_in_free_space_mode?(node, class_elem) ||
-            backslash_b?(class_elem) || backslash_zero?(class_elem) ||
+            backslash_b?(class_elem) || octal_requiring_char_class?(class_elem) ||
             requires_escape_outside_char_class?(class_elem)
 
           !non_redundant
         end
 
-        def multiple_codepoins?(expression)
+        def multiple_codepoints?(expression)
           expression.respond_to?(:codepoints) && expression.codepoints.count >= 2
         end
 
@@ -104,11 +104,10 @@ module RuboCop
           elem == '\b'
         end
 
-        def backslash_zero?(elem)
-          # See https://github.com/rubocop/rubocop/issues/11067 for details - in short "\0" != "0" -
-          # the former means an Unicode code point `"\u0000"`, the latter a number character `"0"`.
-          # Similarly "\032" means "\u001A". Other numbers starting with "\0" can also be mentioned.
-          elem == '\0'
+        def octal_requiring_char_class?(elem)
+          # The octal escapes \1 to \7 only work inside a character class
+          # because they would be a backreference outside it.
+          elem.match?(/\A\\[1-7]\z/)
         end
 
         def requires_escape_outside_char_class?(elem)

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for the instantiation of regexp using redundant `Regexp.new` or `Regexp.compile`.
+      # Autocorrect replaces to regexp literal which is the simplest and fastest.
+      #
+      # @example
+      #
+      #   # bad
+      #   Regexp.new(/regexp/)
+      #   Regexp.compile(/regexp/)
+      #
+      #   # good
+      #   /regexp/
+      #   Regexp.new('regexp')
+      #   Regexp.compile('regexp')
+      #
+      class RedundantRegexpConstructor < Base
+        extend AutoCorrector
+
+        MSG = 'Remove the redundant `Regexp.%<method>s`.'
+        RESTRICT_ON_SEND = %i[new compile].freeze
+
+        # @!method redundant_regexp_constructor(node)
+        def_node_matcher :redundant_regexp_constructor, <<~PATTERN
+          (send
+            (const {nil? cbase} :Regexp) {:new :compile}
+            (regexp $... (regopt $...)))
+        PATTERN
+
+        def on_send(node)
+          return unless (regexp, regopt = redundant_regexp_constructor(node))
+
+          add_offense(node, message: format(MSG, method: node.method_name)) do |corrector|
+            pattern = regexp.map(&:source).join
+            regopt = regopt.join
+
+            corrector.replace(node, "/#{pattern}/#{regopt}")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -44,7 +44,8 @@ module RuboCop
 
         def on_regexp(node)
           each_escape(node) do |char, index, within_character_class|
-            next if allowed_escape?(node, char, index, within_character_class)
+            next if char.valid_encoding? && allowed_escape?(node, char, index,
+                                                            within_character_class)
 
             location = escape_range_at_index(node, index)
 
@@ -74,10 +75,18 @@ module RuboCop
 
         def char_class_begins_or_ends_with_escaped_hyphen?(node, index)
           # The hyphen character is allowed to be escaped within a character class
-          # but it's not necessry to escape hyphen if it's the first or last character
+          # but it's not necessary to escape hyphen if it's the first or last character
           # within the character class. This method checks if that's the case.
           # e.g. "[0-9\\-]" or "[\\-0-9]" would return true
-          node.source[index] == '[' || node.source[index + 3] == ']'
+          content = contents_range(node).source
+
+          if content[index + 2] == ']'
+            true
+          elsif content[index - 1] == '['
+            index < 2 || content[index - 2] != '\\'
+          else
+            false
+          end
         end
 
         def delimiter?(node, char)
@@ -99,7 +108,7 @@ module RuboCop
             end
           end
         # Please remove this `else` branch when support for regexp_parser 1.8 will be dropped.
-        # It's for compatibility with regexp_arser 1.8 and will never be maintained.
+        # 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)|

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

@@ -22,13 +22,18 @@ module RuboCop
       #     return something
       #   end
       #
-      #   # good
+      #   # bad
       #   def test
       #     return something if something_else
       #   end
       #
       #   # good
       #   def test
+      #     something if something_else
+      #   end
+      #
+      #   # good
+      #   def test
       #     if x
       #     elsif y
       #     else
@@ -53,7 +58,7 @@ module RuboCop
 
         MSG = 'Redundant `return` detected.'
         MULTI_RETURN_MSG = 'To return multiple values, use an array.'
-        RESTRICT_ON_SEND = %i[define_method define_singleton_method].freeze
+        RESTRICT_ON_SEND = %i[define_method define_singleton_method lambda].freeze
 
         def on_send(node)
           return unless (parent = node.parent) && parent.block_type?
@@ -108,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)
@@ -135,8 +141,13 @@ 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.modifier_form? || node.ternary?
+          return if node.ternary?
 
           check_branch(node.if_branch)
           check_branch(node.else_branch)

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

@@ -17,7 +17,8 @@ module RuboCop
       # protected scope, you cannot send private messages this way.
       #
       # Note we allow uses of `self` with operators because it would be awkward
-      # otherwise.
+      # otherwise. Also allows the use of `self.it` without arguments in blocks,
+      # as in `0.times { self.it }`, following `Lint/ItWithoutArgumentsInBlock` cop.
       #
       # @example
       #
@@ -107,8 +108,8 @@ module RuboCop
         def on_send(node)
           return unless node.self_receiver? && regular_method_call?(node)
           return if node.parent&.mlhs_type?
-
           return if allowed_send_node?(node)
+          return if it_method_in_block?(node)
 
           add_offense(node.receiver) do |corrector|
             corrector.remove(node.receiver)
@@ -155,6 +156,20 @@ module RuboCop
             KERNEL_METHODS.include?(node.method_name)
         end
 
+        # Respects `Lint/ItWithoutArgumentsInBlock` cop and the following Ruby 3.3's warning:
+        #
+        # $ ruby -e '0.times { begin; it; end }'
+        # -e:1: warning: `it` calls without arguments will refer to the first block param in
+        # Ruby 3.4; use it() or self.it
+        #
+        def it_method_in_block?(node)
+          return false unless node.method?(:it)
+          return false unless (block_node = node.each_ancestor(:block).first)
+          return false unless block_node.arguments.empty_and_without_delimiters?
+
+          node.arguments.empty? && !node.block_literal?
+        end
+
         def regular_method_call?(node)
           !(node.operator_method? ||
             KEYWORDS.include?(node.method_name) ||

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

@@ -62,7 +62,9 @@ module RuboCop
         end
 
         def multiple_statements?(branch)
-          branch && branch.children.compact.count > 1
+          return false unless branch&.begin_type?
+
+          !branch.children.empty?
         end
 
         def self_assign?(variable, branch)
@@ -73,6 +75,11 @@ module RuboCop
           add_offense(offense_branch) do |corrector|
             assignment_value = opposite_branch ? opposite_branch.source : 'nil'
             replacement = "#{assignment_value} #{keyword} #{if_node.condition.source}"
+            if opposite_branch.respond_to?(:heredoc?) && opposite_branch.heredoc?
+              replacement += opposite_branch.loc.heredoc_end.with(
+                begin_pos: opposite_branch.source_range.end_pos
+              ).source
+            end
 
             corrector.replace(if_node, replacement)
           end

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

@@ -16,7 +16,7 @@ module RuboCop
       #   This cop is unsafe, because `sort...last` and `max` may not return the
       #   same element in all cases.
       #
-      #   In an enumerable where there are multiple elements where `a <=> b == 0`,
+      #   In an enumerable where there are multiple elements where ``a <=> b == 0``,
       #   or where the transformation done by the `sort_by` block has the
       #   same result, `sort.last` and `max` (or `sort_by.last` and `max_by`)
       #   will return different elements. `sort.last` will return the last
@@ -87,15 +87,15 @@ module RuboCop
         # @!method redundant_sort?(node)
         def_node_matcher :redundant_sort?, <<~MATCHER
           {
-            (send $(send _ $:sort) ${:last :first})
-            (send $(send _ $:sort) ${:[] :at :slice} {(int 0) (int -1)})
+            (call $(call _ $:sort) ${:last :first})
+            (call $(call _ $:sort) ${:[] :at :slice} {(int 0) (int -1)})
 
-            (send $(send _ $:sort_by _) ${:last :first})
+            (call $(call _ $:sort_by _) ${:last :first})
             (send $(send _ $:sort_by _) ${:[] :at :slice} {(int 0) (int -1)})
 
-            (send ({block numblock} $(send _ ${:sort_by :sort}) ...) ${:last :first})
-            (send
-              ({block numblock} $(send _ ${:sort_by :sort}) ...)
+            (call ({block numblock} $(call _ ${:sort_by :sort}) ...) ${:last :first})
+            (call
+              ({block numblock} $(call _ ${:sort_by :sort}) ...)
               ${:[] :at :slice} {(int 0) (int -1)}
             )
           }
@@ -108,6 +108,7 @@ module RuboCop
 
           register_offense(ancestor, sort_node, sorter, accessor)
         end
+        alias on_csend on_send
 
         private
 
@@ -129,13 +130,13 @@ module RuboCop
         end
 
         def offense_range(sort_node, node)
-          range_between(sort_node.loc.selector.begin_pos, node.loc.expression.end_pos)
+          range_between(sort_node.loc.selector.begin_pos, node.source_range.end_pos)
         end
 
         def message(node, sorter, accessor)
           accessor_source = range_between(
             node.loc.selector.begin_pos,
-            node.loc.expression.end_pos
+            node.source_range.end_pos
           ).source
 
           format(MSG,
@@ -146,7 +147,7 @@ module RuboCop
 
         def autocorrect(corrector, node, sort_node, sorter, accessor)
           # Remove accessor, e.g. `first` or `[-1]`.
-          corrector.remove(range_between(accessor_start(node), node.loc.expression.end_pos))
+          corrector.remove(range_between(accessor_start(node), node.source_range.end_pos))
           # Replace "sort" or "sort_by" with the appropriate min/max method.
           corrector.replace(sort_node.loc.selector, suggestion(sorter, accessor, arg_value(node)))
           # Replace to avoid syntax errors when followed by a logical operator.
@@ -180,7 +181,7 @@ module RuboCop
         end
 
         def arg_node(node)
-          node.arguments.first
+          node.first_argument
         end
 
         def arg_value(node)
@@ -198,7 +199,7 @@ module RuboCop
         end
 
         def with_logical_operator?(node)
-          return unless (parent = node.parent)
+          return false unless (parent = node.parent)
 
           parent.or_type? || parent.and_type?
         end

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

@@ -46,12 +46,12 @@ module RuboCop
 
         # @!method redundant_sort_by_block(node)
         def_node_matcher :redundant_sort_by_block, <<~PATTERN
-          (block $(send _ :sort_by) (args (arg $_x)) (lvar _x))
+          (block $(call _ :sort_by) (args (arg $_x)) (lvar _x))
         PATTERN
 
         # @!method redundant_sort_by_numblock(node)
         def_node_matcher :redundant_sort_by_numblock, <<~PATTERN
-          (numblock $(send _ :sort_by) 1 (lvar :_1))
+          (numblock $(call _ :sort_by) 1 (lvar :_1))
         PATTERN
 
         def sort_by_range(send, node)