rubocop 1.66.1 → 1.69.1

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # Looks for places where an subset of an Enumerable (array,
+      # Looks for places where a subset of an Enumerable (array,
       # range, set, etc.; see note below) is calculated based on a `Regexp`
       # match, and suggests `grep` or `grep_v` instead.
       #
@@ -27,7 +27,7 @@ module RuboCop
       #   so the correction may not be actually equivalent.
       #
       # @example
-      #   # bad (select or find_all)
+      #   # bad (select, filter, or find_all)
       #   array.select { |x| x.match? /regexp/ }
       #   array.select { |x| /regexp/.match?(x) }
       #   array.select { |x| x =~ /regexp/ }
@@ -47,9 +47,11 @@ module RuboCop
         include RangeHelp
 
         MSG = 'Prefer `%<replacement>s` to `%<original_method>s` with a regexp match.'
-        RESTRICT_ON_SEND = %i[select find_all reject].freeze
-        REPLACEMENTS = { select: 'grep', find_all: 'grep', reject: 'grep_v' }.freeze
-        OPPOSITE_REPLACEMENTS = { select: 'grep_v', find_all: 'grep_v', reject: 'grep' }.freeze
+        RESTRICT_ON_SEND = %i[select filter find_all reject].freeze
+        REPLACEMENTS = { select: 'grep', filter: 'grep', find_all: 'grep', reject: 'grep_v' }.freeze
+        OPPOSITE_REPLACEMENTS = {
+          select: 'grep_v', filter: 'grep_v', find_all: 'grep_v', reject: 'grep'
+        }.freeze
         REGEXP_METHODS = %i[match? =~ !~].to_set.freeze
 
         # @!method regexp_match?(node)
@@ -84,8 +86,9 @@ module RuboCop
           }
         PATTERN
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_send(node)
+          return if target_ruby_version < 2.6 && node.method?(:filter)
           return unless (block_node = node.block_node)
           return if block_node.body&.begin_type?
           return if receiver_allowed?(block_node.receiver)
@@ -99,7 +102,7 @@ module RuboCop
 
           register_offense(node, block_node, regexp, replacement)
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         alias on_csend on_send
 
         private

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

@@ -37,33 +37,29 @@ module RuboCop
         private
 
         def check(node, var_type)
-          var_name, rhs = *node
-          return unless rhs
+          return unless (rhs = node.expression)
 
-          if rhs.send_type?
-            check_send_node(node, rhs, var_name, var_type)
+          if rhs.send_type? && rhs.arguments.one?
+            check_send_node(node, rhs, node.name, var_type)
           elsif rhs.operator_keyword?
-            check_boolean_node(node, rhs, var_name, var_type)
+            check_boolean_node(node, rhs, node.name, var_type)
           end
         end
 
         def check_send_node(node, rhs, var_name, var_type)
-          receiver, method_name, *_args = *rhs
-          return unless OPS.include?(method_name)
+          return unless OPS.include?(rhs.method_name)
 
           target_node = s(var_type, var_name)
-          return unless receiver == target_node
+          return unless rhs.receiver == target_node
 
-          add_offense(node, message: format(MSG, method: method_name)) do |corrector|
+          add_offense(node, message: format(MSG, method: rhs.method_name)) do |corrector|
             autocorrect(corrector, node)
           end
         end
 
         def check_boolean_node(node, rhs, var_name, var_type)
-          first_operand, _second_operand = *rhs
-
           target_node = s(var_type, var_name)
-          return unless first_operand == target_node
+          return unless rhs.lhs == target_node
 
           operator = rhs.loc.operator.source
           add_offense(node, message: format(MSG, method: operator)) do |corrector|
@@ -72,7 +68,7 @@ module RuboCop
         end
 
         def autocorrect(corrector, node)
-          _var_name, rhs = *node
+          rhs = node.expression
 
           if rhs.send_type?
             autocorrect_send_node(corrector, node, rhs)
@@ -82,13 +78,11 @@ module RuboCop
         end
 
         def autocorrect_send_node(corrector, node, rhs)
-          _receiver, method_name, args = *rhs
-          apply_autocorrect(corrector, node, rhs, method_name.to_s, args)
+          apply_autocorrect(corrector, node, rhs, rhs.method_name, rhs.first_argument)
         end
 
         def autocorrect_boolean_node(corrector, node, rhs)
-          _first_operand, second_operand = *rhs
-          apply_autocorrect(corrector, node, rhs, rhs.loc.operator.source, second_operand)
+          apply_autocorrect(corrector, node, rhs, rhs.loc.operator.source, rhs.rhs)
         end
 
         def apply_autocorrect(corrector, node, rhs, operator, new_rhs)

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

@@ -141,7 +141,7 @@ module RuboCop
 
         def expressions_per_line(exprs)
           # create a map matching lines to the number of expressions on them
-          exprs_lines = exprs.map(&:first_line)
+          exprs_lines = exprs.map(&:last_line)
           exprs_lines.group_by(&:itself)
         end
 

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

@@ -122,10 +122,9 @@ module RuboCop
         def on_rescue(node)
           return unless style == :semantic
 
-          begin_node, *rescue_nodes, _else_node = *node
-          check_scope(:raise, begin_node)
+          check_scope(:raise, node.body)
 
-          rescue_nodes.each do |rescue_node|
+          node.resbody_branches.each do |rescue_node|
             check_scope(:fail, rescue_node)
             allow(:raise, rescue_node)
           end

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

@@ -33,22 +33,19 @@ module RuboCop
       #
       class SingleArgumentDig < Base
         extend AutoCorrector
+        include DigHelp
 
         MSG = 'Use `%<receiver>s[%<argument>s]` instead of `%<original>s`.'
         RESTRICT_ON_SEND = %i[dig].freeze
         IGNORED_ARGUMENT_TYPES = %i[block_pass forwarded_restarg forwarded_args hash].freeze
 
-        # @!method single_argument_dig?(node)
-        def_node_matcher :single_argument_dig?, <<~PATTERN
-          (send _ :dig $!splat)
-        PATTERN
-
         def on_send(node)
           return unless node.receiver
 
           expression = single_argument_dig?(node)
           return unless expression
           return if IGNORED_ARGUMENT_TYPES.include?(expression.type)
+          return if ignore_dig_chain?(node)
 
           receiver = node.receiver.source
           argument = expression.source
@@ -63,6 +60,13 @@ module RuboCop
 
           ignore_node(node)
         end
+
+        private
+
+        def ignore_dig_chain?(node)
+          dig_chain_enabled? &&
+            (dig?(node.receiver) || dig?(node.parent))
+        end
       end
     end
   end

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

@@ -6,8 +6,13 @@ module RuboCop
       # Checks for single-line `do`...`end` block.
       #
       # In practice a single line `do`...`end` is autocorrected when `EnforcedStyle: semantic`
-      # in `Style/BlockDelimiters`. The autocorrection maintains the `do` ... `end` syntax to
-      # preserve semantics and does not change it to `{`...`}` block.
+      # is configured for `Style/BlockDelimiters`. The autocorrection maintains the
+      # `do` ... `end` syntax to preserve semantics and does not change it to `{`...`}` block.
+      #
+      # NOTE: If `InspectBlocks` is set to `true` for `Layout/RedundantLineBreak`, blocks will
+      # be autocorrected to be on a single line if possible. This cop respects that configuration
+      # by not registering an offense if it would subsequently cause a
+      # `Layout/RedundantLineBreak` offense.
       #
       # @example
       #
@@ -27,12 +32,14 @@ module RuboCop
       #
       class SingleLineDoEndBlock < Base
         extend AutoCorrector
+        include CheckSingleLineSuitability
 
         MSG = 'Prefer multiline `do`...`end` block.'
 
         # rubocop:disable Metrics/AbcSize
         def on_block(node)
           return if !node.single_line? || node.braces?
+          return if single_line_blocks_preferred? && suitable_as_single_line?(node)
 
           add_offense(node) do |corrector|
             corrector.insert_after(do_line(node), "\n")
@@ -60,7 +67,10 @@ module RuboCop
           end
         end
 
-        def x(corrector, node); end
+        def single_line_blocks_preferred?
+          redundant_line_break_config = @config.for_cop('Layout/RedundantLineBreak')
+          redundant_line_break_config['Enabled'] && redundant_line_break_config['InspectBlocks']
+        end
       end
     end
   end

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

@@ -214,7 +214,7 @@ module RuboCop
         end
 
         def insert_bang_for_and(corrector, node)
-          lhs, rhs = *node
+          lhs, rhs = *node # rubocop:disable InternalAffairs/NodeDestructuring
 
           if lhs.and_type?
             insert_bang_for_and(corrector, lhs)
@@ -237,8 +237,7 @@ module RuboCop
         end
 
         def wrap_condition?(node)
-          node.and_type? || node.or_type? ||
-            (node.call_type? && node.arguments.any? && !node.parenthesized?)
+          node.operator_keyword? || (node.call_type? && node.arguments.any? && !node.parenthesized?)
         end
 
         def replace_condition(condition)

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

@@ -149,7 +149,7 @@ module RuboCop
         end
 
         def on_gvar(node)
-          global_var, = *node
+          global_var = node.name
 
           return unless (preferred = preferred_names(global_var))
 

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

@@ -51,7 +51,6 @@ module RuboCop
       #   Pathname.new('/') + 'test'
       #
       class StringConcatenation < Base
-        include Util
         include RangeHelp
         extend AutoCorrector
 
@@ -143,22 +142,24 @@ module RuboCop
         end
 
         def replacement(parts)
-          interpolated_parts =
-            parts.map do |part|
-              case part.type
-              when :str
-                value = part.value
-                single_quoted?(part) ? value.gsub(/(\\|")/, '\\\\\&') : value.inspect[1..-2]
-              when :dstr
-                contents_range(part).source
-              else
-                "\#{#{part.source}}"
-              end
+          interpolated_parts = parts.map do |part|
+            case part.type
+            when :str
+              adjust_str(part)
+            when :dstr
+              part.children.all?(&:str_type?) ? adjust_str(part) : contents_range(part).source
+            else
+              "\#{#{part.source}}"
             end
+          end
 
           "\"#{handle_quotes(interpolated_parts).join}\""
         end
 
+        def adjust_str(node)
+          single_quoted?(node) ? node.value.gsub(/(\\|")/, '\\\\\&') : node.value.inspect[1..-2]
+        end
+
         def handle_quotes(parts)
           parts.map do |part|
             part == '"' ? '\"' : part

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

@@ -33,7 +33,7 @@ module RuboCop
         def on_class(node)
           return unless struct_constructor?(node.parent_class)
 
-          add_offense(node.parent_class.source_range) do |corrector|
+          add_offense(node.parent_class) do |corrector|
             corrector.remove(range_with_surrounding_space(node.loc.keyword, newlines: false))
             corrector.replace(node.loc.operator, '=')
 

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

@@ -79,26 +79,15 @@ module RuboCop
         end
 
         def lhs(node)
-          case node.type
-          when :casgn
-            namespace, name, = *node
-            if namespace
-              "#{namespace.const_name}::#{name}"
-            else
-              name.to_s
-            end
+          if node.casgn_type?
+            "#{'::' if node.absolute?}#{node.const_name}"
           else
-            node.children[0].to_s
+            node.name.to_s
           end
         end
 
         def rhs(node)
-          case node.type
-          when :casgn
-            node.children[2].source
-          else
-            node.children[1].source
-          end
+          node.expression.source
         end
 
         def correction_range(tmp_assign, y_assign)

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

@@ -75,7 +75,7 @@ module RuboCop
 
           message = message(node)
 
-          add_offense(node.source_range, message: message) do |corrector|
+          add_offense(node, message: message) do |corrector|
             autocorrect(corrector, node)
           end
         end
@@ -171,9 +171,7 @@ module RuboCop
         end
 
         def unsafe_autocorrect?(condition)
-          condition.children.any? do |child|
-            unparenthesized_method_call?(child) || below_ternary_precedence?(child)
-          end
+          condition.children.any? { |child| below_ternary_precedence?(child) }
         end
 
         def unparenthesized_method_call?(child)
@@ -192,7 +190,7 @@ module RuboCop
         # @!method method_name(node)
         def_node_matcher :method_name, <<~PATTERN
           {($:defined? _ ...)
-           (send {_ nil?} $_ _ ...)}
+           (call {_ nil?} $_ _ ...)}
         PATTERN
 
         def correct_parenthesized(corrector, condition)
@@ -203,16 +201,39 @@ module RuboCop
           # If we remove the parentheses, we need to add a space or we'll
           # generate invalid code.
           corrector.insert_after(condition.loc.end, ' ') unless whitespace_after?(condition)
+
+          if (send_node = condition.child_nodes.last) && node_args_need_parens?(send_node)
+            parenthesize_condition_arguments(corrector, send_node)
+          end
         end
 
         def correct_unparenthesized(corrector, condition)
           corrector.wrap(condition, '(', ')')
         end
 
+        def parenthesize_condition_arguments(corrector, send_node)
+          range_start = send_node.defined_type? ? send_node.loc.keyword : send_node.loc.selector
+          opening_range = range_start.end.join(send_node.first_argument.source_range.begin)
+
+          corrector.replace(opening_range, '(')
+          corrector.insert_after(send_node.last_argument, ')')
+        end
+
         def whitespace_after?(node)
           last_token = processed_source.last_token_of(node)
           last_token.space_after?
         end
+
+        def node_args_need_parens?(send_node)
+          return false unless node_with_args?(send_node)
+          return false if send_node.arguments.none? || send_node.parenthesized?
+
+          send_node.dot? || send_node.safe_navigation? || unparenthesized_method_call?(send_node)
+        end
+
+        def node_with_args?(node)
+          node.call_type? || node.defined_type?
+        end
       end
     end
   end

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

@@ -94,7 +94,7 @@ module RuboCop
         end
 
         def unneeded_ranges(node)
-          node.masgn_type? ? (mlhs_node, = *node) : mlhs_node = node
+          mlhs_node = node.masgn_type? ? node.lhs : node
           variables = *mlhs_node
 
           main_offense = main_node_offense(node)
@@ -106,15 +106,15 @@ module RuboCop
         end
 
         def main_node_offense(node)
-          node.masgn_type? ? (mlhs_node, right = *node) : mlhs_node = node
-
+          mlhs_node = node.masgn_type? ? node.lhs : node
           variables = *mlhs_node
+
           first_offense = find_first_offense(variables)
 
           return unless first_offense
 
           if unused_variables_only?(first_offense, variables)
-            return unused_range(node.type, mlhs_node, right)
+            return unused_range(node.type, mlhs_node, node.rhs)
           end
 
           return range_for_parentheses(first_offense, mlhs_node) if Util.parentheses?(mlhs_node)

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

@@ -179,7 +179,7 @@ module RuboCop
         end
 
         def looks_like_trivial_reader?(node)
-          !node.arguments? && node.body && node.body.ivar_type?
+          !node.arguments? && node.body&.ivar_type?
         end
 
         def trivial_writer?(node)

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

@@ -19,8 +19,7 @@ module RuboCop
         include Interpolation
         extend AutoCorrector
 
-        MSG = 'Replace interpolated variable `%<variable>s` ' \
-              'with expression `#{%<variable>s}`.' # rubocop:disable Lint/InterpolationCheck
+        MSG = 'Replace interpolated variable `%<variable>s` with expression `#{%<variable>s}`.'
 
         def on_node_with_interpolations(node)
           var_nodes(node.children).each do |var_node|

data/lib/rubocop/cop/team.rb

@@ -9,11 +9,17 @@ module RuboCop
     # For performance reasons, Team will first dispatch cops & forces in two groups,
     # first the ones needed for autocorrection (if any), then the rest
     # (unless autocorrections happened).
+    # rubocop:disable Metrics/ClassLength
     class Team
       # @return [Team]
       def self.new(cop_or_classes, config, options = {})
         # Support v0 api:
-        return mobilize(cop_or_classes, config, options) if cop_or_classes.first.is_a?(Class)
+        if cop_or_classes.first.is_a?(Class)
+          warn Rainbow(<<~WARNING).yellow, uplevel: 1
+            `Team.new` with cop classes is deprecated. Use `Team.mobilize` instead.
+          WARNING
+          return mobilize(cop_or_classes, config, options)
+        end
 
         super
       end
@@ -279,5 +285,6 @@ module RuboCop
         end
       end
     end
+    # rubocop:enable Metrics/ClassLength
   end
 end

data/lib/rubocop/cop/util.rb

@@ -32,7 +32,7 @@ module RuboCop
       end
 
       def parentheses?(node)
-        node.loc.respond_to?(:end) && node.loc.end && node.loc.end.is?(')')
+        node.loc.respond_to?(:end) && node.loc.end&.is?(')')
       end
 
       # rubocop:disable Metrics/AbcSize, Metrics/MethodLength

data/lib/rubocop/cop/variable_force/assignment.rb

@@ -9,9 +9,10 @@ module RuboCop
 
         MULTIPLE_LEFT_HAND_SIDE_TYPE = :mlhs
 
-        attr_reader :node, :variable, :referenced, :references
+        attr_reader :node, :variable, :referenced, :references, :reassigned
 
         alias referenced? referenced
+        alias reassigned? reassigned
 
         def initialize(node, variable)
           unless VARIABLE_ASSIGNMENT_TYPES.include?(node.type)
@@ -24,6 +25,7 @@ module RuboCop
           @variable = variable
           @referenced = false
           @references = []
+          @reassigned = false
         end
 
         def name
@@ -39,8 +41,14 @@ module RuboCop
           @referenced = true
         end
 
+        def reassigned!
+          return if referenced?
+
+          @reassigned = true
+        end
+
         def used?
-          @variable.captured_by_block? || @referenced
+          (!reassigned? && @variable.captured_by_block?) || @referenced
         end
 
         def regexp_named_capture?
@@ -102,6 +110,7 @@ module RuboCop
         end
 
         def multiple_assignment_node
+          return nil unless node.parent&.mlhs_type?
           return nil unless (grandparent_node = node.parent&.parent)
           if (node = find_multiple_assignment_node(grandparent_node))
             return node
@@ -119,7 +128,13 @@ module RuboCop
         end
 
         def for_assignment_node
-          node.ancestors.find(&:for_type?)
+          return unless (parent_node = node.parent)
+          return parent_node if parent_node.for_type?
+
+          grandparent_node = parent_node.parent
+          return grandparent_node if parent_node.mlhs_type? && grandparent_node&.for_type?
+
+          nil
         end
 
         def find_multiple_assignment_node(grandparent_node)

data/lib/rubocop/cop/variable_force/branch.rb

@@ -74,7 +74,7 @@ module RuboCop
           def parent
             return @parent if instance_variable_defined?(:@parent)
 
-            @branch = Branch.of(control_node, scope: scope)
+            @parent = Branch.of(control_node, scope: scope)
           end
 
           def each_ancestor(include_self: false, &block)

data/lib/rubocop/cop/variable_force/variable.rb

@@ -29,7 +29,11 @@ module RuboCop
         end
 
         def assign(node)
-          @assignments << Assignment.new(node, self)
+          assignment = Assignment.new(node, self)
+
+          @assignments.last&.reassigned! unless captured_by_block?
+
+          @assignments << assignment
         end
 
         def referenced?

data/lib/rubocop/cop/variable_force/variable_table.rb

@@ -61,8 +61,8 @@ module RuboCop
                   "at #{node.source_range}, #{node.inspect}"
           end
 
-          variable.assign(node)
           mark_variable_as_captured_by_block_if_so(variable)
+          variable.assign(node)
         end
 
         def reference_variable(name, node)
@@ -87,8 +87,8 @@ module RuboCop
           # So just skip.
           return unless variable
 
-          variable.reference!(node)
           mark_variable_as_captured_by_block_if_so(variable)
+          variable.reference!(node)
         end
 
         def find_variable(name)

data/lib/rubocop/cop/variable_force.rb

@@ -194,15 +194,10 @@ module RuboCop
       end
 
       def process_variable_operator_assignment(node)
-        if LOGICAL_OPERATOR_ASSIGNMENT_TYPES.include?(node.type)
-          asgn_node, rhs_node = *node
-        else
-          asgn_node, _operator, rhs_node = *node
-        end
-
+        asgn_node = node.lhs
         return unless asgn_node.lvasgn_type?
 
-        name = asgn_node.children.first
+        name = asgn_node.name
 
         variable_table.declare_variable(name, asgn_node) unless variable_table.variable_exist?(name)
 
@@ -222,7 +217,7 @@ module RuboCop
         # before processing rhs nodes.
 
         variable_table.reference_variable(name, node)
-        process_node(rhs_node)
+        process_node(node.rhs)
         variable_table.assign_to_variable(name, asgn_node)
 
         skip_children!
@@ -355,8 +350,7 @@ module RuboCop
         when :lvasgn
           AssignmentReference.new(node)
         when *OPERATOR_ASSIGNMENT_TYPES
-          asgn_node = node.children.first
-          VariableReference.new(asgn_node.children.first) if asgn_node.lvasgn_type?
+          VariableReference.new(node.lhs.name) if node.lhs.lvasgn_type?
         end
       end