rubocop 1.66.0 → 1.72.1

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

@@ -55,68 +55,66 @@ module RuboCop
         MSG = 'Avoid comparing a variable with multiple items ' \
               'in a conditional, use `Array#include?` instead.'
 
-        def on_new_investigation
-          reset_comparison
-        end
+        # @!method simple_double_comparison?(node)
+        def_node_matcher :simple_double_comparison?, <<~PATTERN
+          (send lvar :== lvar)
+        PATTERN
+
+        # @!method simple_comparison_lhs(node)
+        def_node_matcher :simple_comparison_lhs, <<~PATTERN
+          (send ${lvar call} :== $_)
+        PATTERN
+
+        # @!method simple_comparison_rhs(node)
+        def_node_matcher :simple_comparison_rhs, <<~PATTERN
+          (send $_ :== ${lvar call})
+        PATTERN
 
+        # rubocop:disable Metrics/AbcSize
         def on_or(node)
           root_of_or_node = root_of_or_node(node)
-
           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
+          return unless nested_comparison?(node)
 
-          add_offense(node) do |corrector|
-            elements = @compared_elements.join(', ')
-            prefer_method = "[#{elements}].include?(#{variables_in_node(node).first})"
+          return unless (variable, values = find_offending_var(node))
+          return if values.size < comparisons_threshold
 
-            corrector.replace(node, prefer_method)
+          range = offense_range(values)
 
-            reset_comparison
+          add_offense(range) do |corrector|
+            elements = values.map(&:source).join(', ')
+            argument = variable.lvar_type? ? variable_name(variable) : variable.source
+            prefer_method = "[#{elements}].include?(#{argument})"
+
+            corrector.replace(range, prefer_method)
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         private
 
-        # @!method simple_double_comparison?(node)
-        def_node_matcher :simple_double_comparison?, '(send $lvar :== $lvar)'
-
-        # @!method simple_comparison_lhs?(node)
-        def_node_matcher :simple_comparison_lhs?, <<~PATTERN
-          (send $lvar :== $_)
-        PATTERN
-
-        # @!method simple_comparison_rhs?(node)
-        def_node_matcher :simple_comparison_rhs?, <<~PATTERN
-          (send $_ :== $lvar)
-        PATTERN
-
-        def nested_variable_comparison?(node)
-          return false unless nested_comparison?(node)
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def find_offending_var(node, variables = Set.new, values = [])
+          if node.or_type?
+            find_offending_var(node.lhs, variables, values)
+            find_offending_var(node.rhs, variables, values)
+          elsif simple_double_comparison?(node)
+            return
+          elsif (var, obj = simple_comparison(node))
+            return if allow_method_comparison? && obj.call_type?
 
-          variables_in_node(node).count == 1
-        end
+            variables << var
+            return if variables.size > 1
 
-        def variables_in_node(node)
-          if node.or_type?
-            node.node_parts.flat_map { |node_part| variables_in_node(node_part) }.uniq
-          else
-            variables_in_simple_node(node)
+            values << obj
           end
-        end
 
-        def variables_in_simple_node(node)
-          simple_double_comparison?(node) do |var1, var2|
-            return [variable_name(var1), variable_name(var2)]
-          end
-          if (var, obj = simple_comparison_lhs?(node)) || (obj, var = simple_comparison_rhs?(node))
-            @allowed_method_comparison = true if allow_method_comparison? && obj.send_type?
-            @compared_elements << obj.source
-            return [variable_name(var)]
-          end
+          [variables.first, values] if variables.any?
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
-          []
+        def offense_range(values)
+          values.first.parent.source_range.begin.join(values.last.parent.source_range.end)
         end
 
         def variable_name(node)
@@ -132,7 +130,15 @@ module RuboCop
         end
 
         def comparison?(node)
-          simple_comparison_lhs?(node) || simple_comparison_rhs?(node) || nested_comparison?(node)
+          !!simple_comparison(node) || nested_comparison?(node)
+        end
+
+        def simple_comparison(node)
+          if (var, obj = simple_comparison_lhs(node)) || (obj, var = simple_comparison_rhs(node))
+            return if var.call_type? && !allow_method_comparison?
+
+            [var, obj]
+          end
         end
 
         def root_of_or_node(or_node)
@@ -145,11 +151,6 @@ module RuboCop
           end
         end
 
-        def reset_comparison
-          @compared_elements = []
-          @allowed_method_comparison = false
-        end
-
         def allow_method_comparison?
           cop_config.fetch('AllowMethodComparison', true)
         end

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

@@ -19,7 +19,7 @@ module RuboCop
       # acceptable value other than none, it will suppress the offenses
       # raised by this cop. It enforces frozen state.
       #
-      # NOTE: Regexp and Range literals are frozen objects since Ruby 3.0.
+      # NOTE: `Regexp` and `Range` literals are frozen objects since Ruby 3.0.
       #
       # NOTE: From Ruby 3.0, interpolated strings are not frozen when
       # `# frozen-string-literal: true` is used, so this cop enforces explicit
@@ -125,15 +125,14 @@ module RuboCop
         MSG = 'Freeze mutable objects assigned to constants.'
 
         def on_casgn(node)
-          _scope, _const_name, value = *node
-          if value.nil? # This is only the case for `CONST += ...` or similarg66
+          if node.expression.nil? # This is only the case for `CONST += ...` or similarg66
             parent = node.parent
             return unless parent.or_asgn_type? # We only care about `CONST ||= ...`
 
-            value = parent.children.last
+            on_assignment(parent.children.last)
+          else
+            on_assignment(node.expression)
           end
-
-          on_assignment(value)
         end
 
         private
@@ -198,7 +197,7 @@ module RuboCop
         end
 
         def frozen_regexp_or_range_literals?(node)
-          target_ruby_version >= 3.0 && (node.regexp_type? || node.range_type?)
+          target_ruby_version >= 3.0 && node.type?(:regexp, :range)
         end
 
         def requires_parentheses?(node)
@@ -239,7 +238,7 @@ module RuboCop
 
         # @!method range_enclosed_in_parentheses?(node)
         def_node_matcher :range_enclosed_in_parentheses?, <<~PATTERN
-          (begin ({irange erange} _ _))
+          (begin (range _ _))
         PATTERN
       end
     end

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

@@ -46,10 +46,12 @@ module RuboCop
           @corrected_nodes = nil
         end
 
+        # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity
         def on_if(node)
           return unless if_else?(node)
           return unless (condition = unwrap_begin_nodes(node.condition))
           return if double_negation?(condition) || !negated_condition?(condition)
+          return unless condition.arguments.size < 2
 
           message = message(node)
           add_offense(node, message: message) do |corrector|
@@ -62,6 +64,7 @@ module RuboCop
             end
           end
         end
+        # rubocop:enable Metrics/AbcSize,Metrics/CyclomaticComplexity
 
         private
 
@@ -71,7 +74,7 @@ module RuboCop
         end
 
         def unwrap_begin_nodes(node)
-          node = node.children.first while node && (node.begin_type? || node.kwbegin_type?)
+          node = node.children.first while node&.type?(:begin, :kwbegin)
 
           node
         end
@@ -92,13 +95,12 @@ module RuboCop
         end
 
         def correct_negated_condition(corrector, node)
-          receiver, method_name, rhs = *node
           replacement =
             if node.negation_method?
-              receiver.source
+              node.receiver.source
             else
-              inverted_method = method_name.to_s.sub('!', '=')
-              "#{receiver.source} #{inverted_method} #{rhs.source}"
+              inverted_method = node.method_name.to_s.sub('!', '=')
+              "#{node.receiver.source} #{inverted_method} #{node.first_argument.source}"
             end
 
           corrector.replace(node, replacement)

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

@@ -36,7 +36,7 @@ module RuboCop
         end
 
         def modifier?(node)
-          node&.basic_conditional? && node&.modifier_form?
+          node&.basic_conditional? && node.modifier_form?
         end
 
         def autocorrect(corrector, node)

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

@@ -35,11 +35,11 @@ module RuboCop
         def on_send(node)
           return unless node.parenthesized?
 
-          node.each_child_node(:send, :csend) do |nested|
+          node.each_child_node(:call) do |nested|
             next if allowed_omission?(nested)
 
             message = format(MSG, source: nested.source)
-            add_offense(nested.source_range, message: message) do |corrector|
+            add_offense(nested, message: message) do |corrector|
               autocorrect(corrector, nested)
             end
           end

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

@@ -18,7 +18,6 @@ module RuboCop
       class NestedTernaryOperator < Base
         extend AutoCorrector
         include RangeHelp
-        include IgnoredNode
 
         MSG = 'Ternary operators must not be nested. Prefer `if` or `else` constructs instead.'
 
@@ -45,9 +44,11 @@ module RuboCop
         end
 
         def remove_parentheses(source)
-          return source unless source.start_with?('(')
-
-          source.delete_prefix('(').delete_suffix(')')
+          if source.start_with?('(') && source.end_with?(')')
+            source.delete_prefix('(').delete_suffix(')')
+          else
+            source
+          end
         end
 
         def replace_loc_and_whitespace(corrector, range, replacement)

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

@@ -52,7 +52,7 @@ module RuboCop
         end
 
         def requires_parens?(child)
-          child.and_type? || child.or_type? ||
+          child.operator_keyword? ||
             (child.send_type? && child.binary_operation?) ||
             (child.if_type? && child.ternary?)
         end

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

@@ -30,11 +30,13 @@ module RuboCop
         minimum_target_ruby_version 2.6
 
         MSG = 'Prefer `%<prefer>s` over `%<current>s`.'
+        RESTRICT_ON_SEND = %i[then yield_self].freeze
 
         def on_block(node)
+          return unless RESTRICT_ON_SEND.include?(node.method_name)
+
           check_method_node(node.send_node)
         end
-
         alias on_numblock on_block
 
         def on_send(node)
@@ -42,29 +44,26 @@ module RuboCop
 
           check_method_node(node)
         end
+        alias on_csend on_send
 
         private
 
         def check_method_node(node)
-          return unless preferred_method?(node)
-
-          message = message(node)
-          add_offense(node.loc.selector, message: message) do |corrector|
-            prefer = style == :then && node.receiver.nil? ? 'self.then' : style
+          if preferred_method?(node)
+            correct_style_detected
+          else
+            opposite_style_detected
+            message = message(node)
+            add_offense(node.loc.selector, message: message) do |corrector|
+              prefer = style == :then && node.receiver.nil? ? 'self.then' : style
 
-            corrector.replace(node.loc.selector, prefer)
+              corrector.replace(node.loc.selector, prefer)
+            end
           end
         end
 
         def preferred_method?(node)
-          case style
-          when :then
-            node.method?(:yield_self)
-          when :yield_self
-            node.method?(:then)
-          else
-            false
-          end
+          node.method?(style)
         end
 
         def message(node)

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

@@ -4,8 +4,8 @@ module RuboCop
   module Cop
     module Style
       # Checks for uses of if/then/else/end constructs on a single line.
-      # AlwaysCorrectToMultiline config option can be set to true to auto-convert all offenses to
-      # multi-line constructs. When AlwaysCorrectToMultiline is false (default case) the
+      # `AlwaysCorrectToMultiline` config option can be set to true to autocorrect all offenses to
+      # multi-line constructs. When `AlwaysCorrectToMultiline` is false (default case) the
       # autocorrect will first try converting them to ternary operators.
       #
       # @example
@@ -30,6 +30,25 @@ module RuboCop
       #   else
       #     baz
       #   end
+      #
+      # @example AlwaysCorrectToMultiline: false (default)
+      #   # bad
+      #   if cond then run else dont end
+      #
+      #   # good
+      #   cond ? run : dont
+      #
+      # @example AlwaysCorrectToMultiline: true
+      #   # bad
+      #   if cond then run else dont end
+      #
+      #   # good
+      #   if cond
+      #     run
+      #   else
+      #     dont
+      #   end
+      #
       class OneLineConditional < Base
         include Alignment
         include ConfigurableEnforcedStyle
@@ -46,7 +65,11 @@ module RuboCop
 
           message = message(node)
           add_offense(node, message: message) do |corrector|
+            next if part_of_ignored_node?(node)
+
             autocorrect(corrector, node)
+
+            ignore_node(node)
           end
         end
 
@@ -79,11 +102,13 @@ module RuboCop
         end
 
         def cannot_replace_to_ternary?(node)
-          node.elsif_conditional?
+          return true if node.elsif_conditional?
+
+          node.else_branch.begin_type? && node.else_branch.children.compact.count >= 2
         end
 
         def ternary_replacement(node)
-          condition, if_branch, else_branch = *node
+          condition, if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring
 
           "#{expr_replacement(condition)} ? " \
             "#{expr_replacement(if_branch)} : " \

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

@@ -3,15 +3,15 @@
 module RuboCop
   module Cop
     module Style
-      # Flags uses of OpenStruct, as it is now officially discouraged
+      # Flags uses of `OpenStruct`, as it is now officially discouraged
       # to be used for performance, version compatibility, and potential security issues.
       #
       # @safety
-      #
       #   Note that this cop may flag false positives; for instance, the following legal
       #   use of a hand-rolled `OpenStruct` type would be considered an offense:
       #
-      #   ```
+      #   [source,ruby]
+      #   -----
       #   module MyNamespace
       #     class OpenStruct # not the OpenStruct we're looking for
       #     end
@@ -20,7 +20,7 @@ module RuboCop
       #       OpenStruct.new # resolves to MyNamespace::OpenStruct
       #     end
       #   end
-      #   ```
+      #   -----
       #
       # @example
       #
@@ -61,7 +61,7 @@ module RuboCop
         def custom_class_or_module_definition?(node)
           parent = node.parent
 
-          (parent.class_type? || parent.module_type?) && node.left_siblings.empty?
+          parent.type?(:class, :module) && node.left_siblings.empty?
         end
       end
     end

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

@@ -22,21 +22,25 @@ module RuboCop
 
         MSG = 'Redundant dot detected.'
         RESTRICT_ON_SEND = %i[| ^ & <=> == === =~ > >= < <= << >> + - * / % ** ~ ! != !~].freeze
+        INVALID_SYNTAX_ARG_TYPES = %i[
+          splat kwsplat forwarded_args forwarded_restarg forwarded_kwrestarg block_pass
+        ].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?
 
-          _lhs, _op, rhs = *node
-          return if !rhs || method_call_with_parenthesized_arg?(rhs) || anonymous_forwarding?(rhs)
+          return unless (rhs = node.first_argument)
+          return if method_call_with_parenthesized_arg?(rhs)
+          return if invalid_syntax_argument?(rhs)
 
           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
+            corrector.insert_after(selector, ' ') if insert_space_after?(node)
           end
         end
         # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
@@ -50,11 +54,10 @@ module RuboCop
           argument.children.first && argument.parent.parenthesized?
         end
 
-        def anonymous_forwarding?(argument)
-          return true if argument.forwarded_args_type? || argument.forwarded_restarg_type?
-          return true if argument.hash_type? && argument.children.first&.forwarded_kwrestarg_type?
+        def invalid_syntax_argument?(argument)
+          type = argument.hash_type? ? argument.children.first&.type : argument.type
 
-          argument.block_pass_type? && argument.source == '&'
+          INVALID_SYNTAX_ARG_TYPES.include?(type)
         end
 
         def wrap_in_parentheses_if_chained(corrector, node)
@@ -67,6 +70,21 @@ module RuboCop
           corrector.insert_after(operator, ' ')
           corrector.wrap(node, '(', ')')
         end
+
+        def insert_space_after?(node)
+          rhs = node.first_argument
+          selector = node.loc.selector
+
+          return true if selector.end_pos == rhs.source_range.begin_pos
+          return false if node.parent&.call_type? # if chained, a space is already added
+
+          # For `/` operations, if the RHS starts with a `(` without space,
+          # add one to avoid a syntax error.
+          range = selector.end.join(rhs.source_range.begin)
+          return true if node.method?(:/) && range.source == '('
+
+          false
+        end
       end
     end
   end

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

@@ -78,18 +78,15 @@ module RuboCop
         end
 
         def take_variable_and_default_from_ternary(node)
-          variable, if_statement = *node
-          [variable, if_statement.else_branch]
+          [node.name, node.expression.else_branch]
         end
 
         def take_variable_and_default_from_unless(node)
           if node.if_branch
-            variable, default = *node.if_branch
+            [node.if_branch.name, node.if_branch.expression]
           else
-            variable, default = *node.else_branch
+            [node.else_branch.name, node.else_branch.expression]
           end
-
-          [variable, default]
         end
       end
     end

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

@@ -28,28 +28,25 @@ module RuboCop
 
         MSG = 'Do not use parallel assignment.'
 
-        def on_masgn(node)
-          lhs, rhs = *node
-          lhs_elements = *lhs
+        def on_masgn(node) # rubocop:disable Metrics/AbcSize
+          rhs = node.rhs
           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)
+          return if allowed_lhs?(node.assignments) || allowed_rhs?(rhs) ||
+                    allowed_masign?(node.assignments, rhs_elements)
 
           range = node.source_range.begin.join(rhs.source_range.end)
 
           add_offense(range) do |corrector|
-            autocorrect(corrector, node, lhs, rhs)
+            autocorrect(corrector, node, rhs)
           end
         end
 
         private
 
-        def autocorrect(corrector, node, lhs, rhs)
-          left_elements = *lhs
-          right_elements = Array(rhs).compact
-          order = find_valid_order(left_elements, right_elements)
+        def autocorrect(corrector, node, rhs)
+          order = find_valid_order(node.assignments, Array(rhs).compact)
           correction = assignment_corrector(node, rhs, order)
 
           corrector.replace(correction.correction_range, correction.correction)
@@ -61,9 +58,7 @@ module RuboCop
                               add_self_to_getters(rhs_elements))
         end
 
-        def allowed_lhs?(node)
-          elements = *node
-
+        def allowed_lhs?(elements)
           # Account for edge cases using one variable with a comma
           # E.g.: `foo, = *bar`
           elements.one? || elements.any?(&:splat_type?)
@@ -74,11 +69,7 @@ module RuboCop
           elements = Array(node).compact
 
           # Account for edge case of `Constant::CONSTANT`
-          !node.array_type? || return_of_method_call?(node) || elements.any?(&:splat_type?)
-        end
-
-        def return_of_method_call?(node)
-          node.block_type? || node.send_type?
+          !node.array_type? || elements.any?(&:splat_type?)
         end
 
         def assignment_corrector(node, rhs, order)

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

@@ -94,8 +94,8 @@ module RuboCop
         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?
+          return false unless node.type?(:while, :until)
+          return false unless condition_body.any_block_type?
 
           condition_body.send_node.block_literal? && condition_body.keywords?
         end

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

@@ -99,7 +99,7 @@ module RuboCop
         def string_source(node)
           if node.is_a?(String)
             node.scrub
-          elsif node.respond_to?(:type) && (node.str_type? || node.sym_type?)
+          elsif node.respond_to?(:type) && node.type?(:str, :sym)
             node.source
           end
         end

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

@@ -19,8 +19,7 @@ module RuboCop
         MSG = 'Use `proc` instead of `Proc.new`.'
 
         # @!method proc_new?(node)
-        def_node_matcher :proc_new?,
-                         '({block numblock} $(send (const {nil? cbase} :Proc) :new) ...)'
+        def_node_matcher :proc_new?, '(any_block $(send (const {nil? cbase} :Proc) :new) ...)'
 
         def on_block(node)
           proc_new?(node) do |block_method|

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

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