rubocop 1.59.0 → 1.68.0

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

@@ -54,10 +54,6 @@ module RuboCop
 
           same_line?(when_node, when_node.body)
         end
-
-        def accept_node_type?(node)
-          node&.array_type? || node&.hash_type?
-        end
       end
     end
   end

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

@@ -55,28 +55,20 @@ module RuboCop
         MSG = 'Avoid comparing a variable with multiple items ' \
               'in a conditional, use `Array#include?` instead.'
 
-        def on_new_investigation
-          @last_comparison = nil
-        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
-          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)
+
+          return unless (variable, values = find_offending_var(node))
+          return if values.size < comparisons_threshold
 
           add_offense(node) do |corrector|
-            elements = @compared_elements.join(', ')
-            prefer_method = "[#{elements}].include?(#{variables_in_node(node).first})"
+            elements = values.map(&:source).join(', ')
+            prefer_method = "[#{elements}].include?(#{variable_name(variable)})"
 
             corrector.replace(node, prefer_method)
           end
-
-          @last_comparison = node
         end
 
         private
@@ -94,32 +86,25 @@ module RuboCop
           (send $_ :== $lvar)
         PATTERN
 
-        def nested_variable_comparison?(node)
-          return false unless nested_comparison?(node)
-
-          variables_in_node(node).count == 1
-        end
-
-        def variables_in_node(node)
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def find_offending_var(node, variables = Set.new, values = [])
           if node.or_type?
-            node.node_parts.flat_map { |node_part| variables_in_node(node_part) }.uniq
-          else
-            variables_in_simple_node(node)
-          end
-        end
+            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.send_type?
 
-        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)]
+            variables << var
+            return if variables.size > 1
+
+            values << obj
           end
 
-          []
+          [variables.first, values] if variables.any?
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def variable_name(node)
           node.children[0]
@@ -134,7 +119,14 @@ 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))
+            [var, obj]
+          end
         end
 
         def root_of_or_node(or_node)
@@ -147,17 +139,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
-        end
-
         def allow_method_comparison?
           cop_config.fetch('AllowMethodComparison', true)
         end

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

@@ -39,7 +39,7 @@ module RuboCop
             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/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_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
@@ -118,12 +118,14 @@ module RuboCop
 
           return unless numeric && operator && replacement_supported?(operator)
 
-          [numeric, replacement(numeric, operator)]
+          [numeric, replacement(node, numeric, operator)]
         end
 
-        def replacement(numeric, operation)
+        def replacement(node, numeric, operation)
           if style == :predicate
             [parenthesized_source(numeric), REPLACEMENTS.invert[operation.to_s]].join('.')
+          elsif negated?(node)
+            "(#{numeric.source} #{REPLACEMENTS[operation.to_s]} 0)"
           else
             [numeric.source, REPLACEMENTS[operation.to_s], 0].join(' ')
           end
@@ -157,6 +159,12 @@ module RuboCop
           end
         end
 
+        def negated?(node)
+          return false unless (parent = node.parent)
+
+          parent.send_type? && parent.method?(:!)
+        end
+
         # @!method predicate(node)
         def_node_matcher :predicate, <<~PATTERN
           (send $(...) ${:zero? :positive? :negative?})

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

@@ -42,11 +42,15 @@ 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|
+            next if part_of_ignored_node?(node)
+
             autocorrect(corrector, node)
+
+            ignore_node(node)
           end
         end
 
@@ -75,7 +79,7 @@ module RuboCop
         end
 
         def always_multiline?
-          @config.for_cop('Style/OneLineConditional')['AlwaysCorrectToMultiline']
+          cop_config['AlwaysCorrectToMultiline']
         end
 
         def cannot_replace_to_ternary?(node)

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

@@ -22,6 +22,9 @@ 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)
@@ -29,14 +32,16 @@ module RuboCop
           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)
+          if !rhs || method_call_with_parenthesized_arg?(rhs) || invalid_syntax_argument?(rhs)
+            return
+          end
 
           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 +55,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 +71,21 @@ module RuboCop
           corrector.insert_after(operator, ' ')
           corrector.wrap(node, '(', ')')
         end
+
+        def insert_space_after?(node)
+          _lhs, op, rhs = *node
+          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 op == :/ && range.source == '('
+
+          false
+        end
       end
     end
   end

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

@@ -142,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)
@@ -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
@@ -289,9 +290,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/quoted_symbols.rb

@@ -9,7 +9,7 @@ module RuboCop
       #
       # String interpolation is always kept in double quotes.
       #
-      # Note: `Lint/SymbolConversion` can be used in parallel to ensure that symbols
+      # NOTE: `Lint/SymbolConversion` can be used in parallel to ensure that symbols
       # are not quoted that don't need to be. This cop is for configuring the quoting
       # style to use for symbols that require quotes.
       #
@@ -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/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

@@ -81,14 +81,20 @@ module RuboCop
           redundant_argument = redundant_arg_for_method(node.method_name.to_s)
           return false if redundant_argument.nil?
 
-          node.first_argument == redundant_argument
+          target_argument = if node.first_argument.respond_to?(:value)
+                              node.first_argument.value
+                            else
+                              node.first_argument
+                            end
+
+          argument_matched?(target_argument, 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)
@@ -98,6 +104,23 @@ module RuboCop
             range_with_surrounding_space(node.first_argument.source_range, newlines: false)
           end
         end
+
+        def argument_matched?(target_argument, redundant_argument)
+          argument = if target_argument.is_a?(AST::Node)
+                       target_argument.source
+                     elsif exclude_cntrl_character?(target_argument, redundant_argument)
+                       target_argument.inspect
+                     else
+                       target_argument.to_s
+                     end
+
+          argument == redundant_argument
+        end
+
+        def exclude_cntrl_character?(target_argument, redundant_argument)
+          !target_argument.to_s.sub(/\A'/, '"').sub(/'\z/, '"').match?(/[[:cntrl:]]/) ||
+            !redundant_argument.match?(/[[:cntrl:]]/)
+        end
       end
     end
   end

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

@@ -54,12 +54,14 @@ module RuboCop
 
         private
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def check_branch(node)
           return unless node
 
           case node.type
-          when :case   then check_case_node(node)
-          when :if     then check_if_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, :resbody
             check_rescue_node(node)
           when :ensure then check_ensure_node(node)
@@ -67,12 +69,18 @@ module RuboCop
             check_begin_node(node)
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def check_case_node(node)
           node.when_branches.each { |when_node| check_branch(when_node.body) }
           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?
 

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

@@ -68,6 +68,10 @@ module RuboCop
 
         MSG = 'Redundant `begin` block detected.'
 
+        def self.autocorrect_incompatible_with
+          [Style::BlockDelimiters]
+        end
+
         # @!method offensive_kwbegins(node)
         def_node_search :offensive_kwbegins, <<~PATTERN
           [(kwbegin ...) !#allowable_kwbegin?]
@@ -75,7 +79,7 @@ module RuboCop
 
         def on_def(node)
           return unless node.body&.kwbegin_type?
-          return if node.endless? && !node.body.children.one?
+          return if node.endless?
 
           register_offense(node.body)
         end

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

@@ -12,7 +12,6 @@ module RuboCop
       #   # good
       #   a = b || c
       #
-      # @example
       #   # bad
       #   if b
       #     b
@@ -40,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)
 
@@ -58,6 +57,7 @@ module RuboCop
             end
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         private
 
@@ -94,7 +94,7 @@ module RuboCop
         end
 
         def use_hash_key_assignment?(else_branch)
-          else_branch&.send_type? && else_branch&.method?(:[]=)
+          else_branch&.send_type? && else_branch.method?(:[]=)
         end
 
         def use_hash_key_access?(node)

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

@@ -18,14 +18,15 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Remove the redundant current directory path.'
+        RESTRICT_ON_SEND = %i[require_relative].freeze
         CURRENT_DIRECTORY_PATH = './'
 
         def on_send(node)
-          return unless node.method?(:require_relative)
-          return unless node.first_argument.str_content&.start_with?(CURRENT_DIRECTORY_PATH)
-          return unless (index = node.first_argument.source.index(CURRENT_DIRECTORY_PATH))
+          return unless (first_argument = node.first_argument)
+          return unless first_argument.str_content&.start_with?(CURRENT_DIRECTORY_PATH)
+          return unless (index = first_argument.source.index(CURRENT_DIRECTORY_PATH))
 
-          begin_pos = node.first_argument.source_range.begin.begin_pos + index
+          begin_pos = first_argument.source_range.begin.begin_pos + index
           range = range_between(begin_pos, begin_pos + 2)
 
           add_offense(range) do |corrector|

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

@@ -56,6 +56,7 @@ module RuboCop
             end
           end
         end
+        alias on_csend on_send
 
         private
 
@@ -64,7 +65,7 @@ module RuboCop
           return if node.last_argument&.block_pass_type?
 
           if node.method?(:each) && !node.parent&.block_type?
-            ancestor_node = node.each_ancestor(:send).detect do |ancestor|
+            ancestor_node = node.each_ancestor(:send, :csend).detect do |ancestor|
               ancestor.receiver == node &&
                 (RESTRICT_ON_SEND.include?(ancestor.method_name) || ancestor.method?(:reverse_each))
             end
@@ -83,10 +84,12 @@ module RuboCop
         # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def range(node)
-          if node.method?(:each)
-            node.loc.dot.join(node.loc.selector)
+          return node.selector unless node.method?(:each)
+
+          if node.parent&.call_type?
+            node.selector.join(node.parent.loc.dot)
           else
-            node.loc.selector
+            node.loc.dot.join(node.selector)
           end
         end
 

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

@@ -6,7 +6,7 @@ module RuboCop
       # Checks for the presence of superfluous `.rb` extension in
       # the filename provided to `require` and `require_relative`.
       #
-      # Note: If the extension is omitted, Ruby tries adding '.rb', '.so',
+      # NOTE: If the extension is omitted, Ruby tries adding '.rb', '.so',
       #       and so on to the name until found. If the file named cannot be found,
       #       a `LoadError` will be raised.
       #       There is an edge case where `foo.so` file is loaded instead of a `LoadError`

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

@@ -79,7 +79,7 @@ module RuboCop
         private_constant :REPLACEMENT_METHODS
 
         def on_send(node)
-          return if node.arguments? || node.block_node
+          return if node.arguments? || node.block_literal?
 
           select_predicate?(node) do |select_node, filter_method|
             return if RAILS_METHODS.include?(filter_method) && !active_support_extensions_enabled?