rubocop 1.48.1 → 1.62.1

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

@@ -8,6 +8,9 @@ module RuboCop
       # This cop can be customized allowed methods with `AllowedMethods`.
       # By default, there are no methods to allowed.
       #
+      # NOTE: This cop allows the use of `it()` without arguments in blocks,
+      # as in `0.times { it() }`, following `Lint/ItWithoutArgumentsInBlock` cop.
+      #
       # @example
       #   # bad
       #   object.some_method()
@@ -30,15 +33,18 @@ module RuboCop
 
         MSG = 'Do not use parentheses for method calls with no arguments.'
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def on_send(node)
           return unless !node.arguments? && node.parenthesized?
           return if ineligible_node?(node)
           return if default_argument?(node)
           return if allowed_method_name?(node.method_name)
           return if same_name_assignment?(node)
+          return if parenthesized_it_method_in_block?(node)
 
           register_offense(node)
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         private
 
@@ -71,6 +77,20 @@ module RuboCop
           end
         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 parenthesized_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.receiver && node.arguments.empty? && !node.block_literal?
+        end
+
         def any_assignment?(node)
           node.each_ancestor(*AST::Node::ASSIGNMENTS).any? do |asgn_node|
             # `obj.method = value` parses as (send ... :method= ...), and will

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

@@ -170,7 +170,7 @@ module RuboCop
           return true if node.arguments.any? do |arg|
             arg.forward_arg_type? || arg.restarg_type? || arg.kwrestarg_type?
           end
-          return false unless (last_argument = node.arguments.last)
+          return false unless (last_argument = node.last_argument)
 
           last_argument.blockarg_type? && last_argument.name.nil?
         end

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

@@ -7,12 +7,12 @@ module RuboCop
       # defining `respond_to_missing?`.
       #
       # @example
-      #   #bad
+      #   # bad
       #   def method_missing(name, *args)
       #     # ...
       #   end
       #
-      #   #good
+      #   # good
       #   def respond_to_missing?(name, include_private)
       #     # ...
       #   end

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

@@ -40,7 +40,7 @@ module RuboCop
         def on_class(node)
           begin_node = node.child_nodes.find(&:begin_type?) || node
           begin_node.each_child_node(:send).select(&:macro?).each do |macro|
-            next unless MIXIN_METHODS.include?(macro.method_name)
+            next if !MIXIN_METHODS.include?(macro.method_name) || macro.arguments.empty?
 
             check(macro)
           end

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

@@ -28,7 +28,7 @@ module RuboCop
         MSG = 'Avoid multi-line chains of blocks.'
 
         def on_block(node)
-          node.send_node.each_node(:send) do |send_node|
+          node.send_node.each_node(:send, :csend) do |send_node|
             receiver = send_node.receiver
 
             next unless (receiver&.block_type? || receiver&.numblock_type?) && receiver&.multiline?

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

@@ -28,14 +28,18 @@ module RuboCop
           return unless node.arguments?
           return if opening_line(node) == closing_line(node)
           return if correction_exceeds_max_line_length?(node)
+          return unless (begin_of_arguments = node.arguments.loc.begin)
 
-          add_offense(node) { |corrector| autocorrect(corrector, node) }
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node, begin_of_arguments)
+          end
         end
         alias on_defs on_def
 
         private
 
-        def autocorrect(corrector, node)
+        # rubocop:disable Metrics/AbcSize
+        def autocorrect(corrector, node, begin_of_arguments)
           arguments = node.arguments
           joined_arguments = arguments.map(&:source).join(', ')
           last_line_source_of_arguments = last_line_source_of_arguments(arguments)
@@ -46,9 +50,17 @@ module RuboCop
             corrector.remove(range_by_whole_lines(arguments.loc.end, include_final_newline: true))
           end
 
-          corrector.remove(arguments_range(node))
-          corrector.insert_after(arguments.loc.begin, joined_arguments)
+          arguments_range = arguments_range(node)
+          # If the method name isn't on the same line as def, move it directly after def
+          if arguments_range.first_line != opening_line(node)
+            corrector.remove(node.loc.name)
+            corrector.insert_after(node.loc.keyword, " #{node.loc.name.source}")
+          end
+
+          corrector.remove(arguments_range)
+          corrector.insert_after(begin_of_arguments, joined_arguments)
         end
+        # rubocop:enable Metrics/AbcSize
 
         def last_line_source_of_arguments(arguments)
           processed_source[arguments.last_line - 1].strip

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

@@ -39,7 +39,7 @@ module RuboCop
 
         MSG_IF = 'Avoid multi-line ternary operators, use `if` or `unless` instead.'
         MSG_SINGLE_LINE = 'Avoid multi-line ternary operators, use single-line instead.'
-        SINGLE_LINE_TYPES = %i[return break next send].freeze
+        SINGLE_LINE_TYPES = %i[return break next send csend].freeze
 
         def on_if(node)
           return unless offense?(node)
@@ -47,19 +47,21 @@ module RuboCop
           message = enforce_single_line_ternary_operator?(node) ? MSG_SINGLE_LINE : MSG_IF
 
           add_offense(node, message: message) do |corrector|
+            next if part_of_ignored_node?(node)
+
             autocorrect(corrector, node)
+
+            ignore_node(node)
           end
         end
 
         private
 
         def offense?(node)
-          node.ternary? && node.multiline?
+          node.ternary? && node.multiline? && node.source != replacement(node)
         end
 
         def autocorrect(corrector, node)
-          return unless offense?(node)
-
           corrector.replace(node, replacement(node))
           return unless (parent = node.parent)
           return unless (comments_in_condition = comments_in_condition(node))

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

@@ -40,6 +40,15 @@ module RuboCop
       #
       #   # good
       #   foo if [b.lightweight, b.heavyweight].include?(a)
+      #
+      # @example ComparisonsThreshold: 2 (default)
+      #   # bad
+      #   foo if a == 'a' || a == 'b'
+      #
+      # @example ComparisonsThreshold: 3
+      #   # good
+      #   foo if a == 'a' || a == 'b'
+      #
       class MultipleComparison < Base
         extend AutoCorrector
 
@@ -58,6 +67,7 @@ module RuboCop
           return unless node == root_of_or_node
           return unless nested_variable_comparison?(root_of_or_node)
           return if @allowed_method_comparison
+          return if @compared_elements.size < comparisons_threshold
 
           add_offense(node) do |corrector|
             elements = @compared_elements.join(', ')
@@ -151,6 +161,10 @@ module RuboCop
         def allow_method_comparison?
           cop_config.fetch('AllowMethodComparison', true)
         end
+
+        def comparisons_threshold
+          cop_config.fetch('ComparisonsThreshold', 2)
+        end
       end
     end
   end

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

@@ -27,24 +27,16 @@ module RuboCop
 
           node.each_descendant(:if).select(&:ternary?).each do |nested_ternary|
             add_offense(nested_ternary) do |corrector|
-              if_node = if_node(nested_ternary)
-              next if part_of_ignored_node?(if_node)
+              next if part_of_ignored_node?(node)
 
-              autocorrect(corrector, if_node)
-              ignore_node(if_node)
+              autocorrect(corrector, node)
+              ignore_node(node)
             end
           end
         end
 
         private
 
-        def if_node(node)
-          node = node.parent
-          return node if node.if_type?
-
-          if_node(node)
-        end
-
         def autocorrect(corrector, if_node)
           replace_loc_and_whitespace(corrector, if_node.loc.question, "\n")
           replace_loc_and_whitespace(corrector, if_node.loc.colon, "\nelse\n")

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

@@ -66,7 +66,7 @@ module RuboCop
         end
 
         def on_block(node)
-          return unless node.send_node.send_type? && node.send_node.enumerator_method?
+          return unless node.send_node.call_type? && node.send_node.enumerator_method?
 
           check(node)
         end

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

@@ -44,6 +44,8 @@ module RuboCop
         def_node_matcher :nil_check?, '(send _ :nil?)'
 
         def on_send(node)
+          return unless node.receiver
+
           style_check?(node) do
             add_offense(node.loc.selector) do |corrector|
               new_code = if prefer_comparison?

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

@@ -62,7 +62,7 @@ module RuboCop
         private
 
         def message(node)
-          self.class.const_get("#{literal_type(node).upcase}_MSG")
+          self.class.const_get(:"#{literal_type(node).upcase}_MSG")
         end
 
         def literal_type(node)

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

@@ -121,7 +121,7 @@ module RuboCop
 
         def allowed_patterns
           # Convert the patterns to be anchored
-          super.map { |regexp| Regexp.new(/\A#{regexp}\z/) }
+          super.map { |regexp| /\A#{regexp}\z/ }
         end
       end
     end

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

@@ -46,15 +46,17 @@ module RuboCop
         private
 
         def check_method_node(node)
-          return unless preferred_method(node)
+          return unless preferred_method?(node)
 
           message = message(node)
           add_offense(node.loc.selector, message: message) do |corrector|
-            corrector.replace(node.loc.selector, style.to_s)
+            prefer = style == :then && node.receiver.nil? ? 'self.then' : style
+
+            corrector.replace(node.loc.selector, prefer)
           end
         end
 
-        def preferred_method(node)
+        def preferred_method?(node)
           case style
           when :then
             node.method?(:yield_self)

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

@@ -45,7 +45,7 @@ module RuboCop
         MSG = 'Avoid using `OpenStruct`; use `Struct`, `Hash`, a class or test doubles instead.'
 
         # @!method uses_open_struct?(node)
-        def_node_matcher :uses_open_struct?, <<-PATTERN
+        def_node_matcher :uses_open_struct?, <<~PATTERN
           (const {nil? (cbase)} :OpenStruct)
         PATTERN
 

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

@@ -4,8 +4,8 @@ module RuboCop
   module Cop
     module Style
       # Checks for redundant dot before operator method call.
-      # The target operator methods are `|`, `^`, `&`, `<=>`, `==`, `===`, `=~`, `>`, `>=`, `<`,
-      # `<=`, `<<`, `>>`, `+`, `-`, `*`, `/`, `%`, `**`, `~`, `!`, `!=`, and `!~`.
+      # The target operator methods are `|`, `^`, `&`, ``<=>``, `==`, `===`, `=~`, `>`, `>=`, `<`,
+      # ``<=``, `<<`, `>>`, `+`, `-`, `*`, `/`, `%`, `**`, `~`, `!`, `!=`, and `!~`.
       #
       # @example
       #
@@ -23,6 +23,7 @@ module RuboCop
         MSG = 'Redundant dot detected.'
         RESTRICT_ON_SEND = %i[| ^ & <=> == === =~ > >= < <= << >> + - * / % ** ~ ! != !~].freeze
 
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
         def on_send(node)
           return unless (dot = node.loc.dot)
           return if node.receiver.const_type? || !node.arguments.one?
@@ -33,8 +34,12 @@ module RuboCop
           add_offense(dot) do |corrector|
             wrap_in_parentheses_if_chained(corrector, node)
             corrector.replace(dot, ' ')
+
+            selector = node.loc.selector
+            corrector.insert_after(selector, ' ') if selector.end_pos == rhs.source_range.begin_pos
           end
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
 
         private
 
@@ -54,6 +59,7 @@ module RuboCop
 
         def wrap_in_parentheses_if_chained(corrector, node)
           return unless node.parent&.call_type?
+          return if node.parent.first_argument == node
 
           operator = node.loc.selector
 

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)
@@ -181,10 +190,12 @@ module RuboCop
         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
@@ -228,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)
@@ -242,7 +250,7 @@ module RuboCop
           end
 
           def correction_range
-            node.parent.source_range
+            rhs.parent.parent.source_range
           end
 
           private
@@ -281,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

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

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

@@ -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/preferred_hash_methods.rb

@@ -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/raise_args.rb

@@ -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,7 +80,7 @@ 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.receiver&.source || exception_node.source

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

@@ -35,6 +35,8 @@ module RuboCop
       #   array.join('')
       #   [1, 2, 3].join("")
       #   array.sum(0)
+      #   exit(true)
+      #   exit!(false)
       #   string.split(" ")
       #   "first\nsecond".split(" ")
       #   string.chomp("\n")
@@ -45,6 +47,8 @@ module RuboCop
       #   array.join
       #   [1, 2, 3].join
       #   array.sum
+      #   exit
+      #   exit!
       #   string.split
       #   "first second".split
       #   string.chomp
@@ -55,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
 
@@ -75,14 +81,14 @@ module RuboCop
           redundant_argument = redundant_arg_for_method(node.method_name.to_s)
           return false if redundant_argument.nil?
 
-          node.arguments.first == redundant_argument
+          node.first_argument.source.sub(/\A'/, '"').sub(/'\z/, '"') == 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)