rubocop 1.67.0 → 1.73.0

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

@@ -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.type?(:call, :defined?)
+        end
       end
     end
   end

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

@@ -77,7 +77,7 @@ module RuboCop
 
         # @!method define_method_block?(node)
         def_node_matcher :define_method_block?, <<~PATTERN
-          ({block numblock} (send _ :define_method _) ...)
+          (any_block (send _ :define_method _) ...)
         PATTERN
       end
     end

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

@@ -7,12 +7,15 @@ module RuboCop
       # The supported styles are:
       #
       # * `consistent_comma`: Requires a comma after the last argument,
-      # for all parenthesized method calls with arguments.
+      # for all parenthesized multi-line method calls with arguments.
       # * `comma`: Requires a comma after the last argument, but only for
       # parenthesized method calls where each argument is on its own line.
       # * `no_comma`: Requires that there is no comma after the last
       # argument.
       #
+      # Regardless of style, trailing commas are not allowed in
+      # single-line method calls.
+      #
       # @example EnforcedStyleForMultiline: consistent_comma
       #   # bad
       #   method(1, 2,)

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

@@ -6,12 +6,13 @@ module RuboCop
       # Checks for trailing comma in array literals.
       # The configuration options are:
       #
-      # * `consistent_comma`: Requires a comma after the
-      # last item of all non-empty, multiline array literals.
-      # * `comma`: Requires a comma after last item in an array,
-      # but only when each item is on its own line.
-      # * `no_comma`: Does not require a comma after the
-      # last item in an array
+      # * `consistent_comma`: Requires a comma after the last item of all non-empty, multiline array
+      # literals.
+      # * `comma`: Requires a comma after the last item in an array, but only when each item is on
+      # its own line.
+      # * `diff_comma`: Requires a comma after the last item in an array, but only when that item is
+      # followed by an immediate newline.
+      # * `no_comma`: Does not require a comma after the last item in an array
       #
       # @example EnforcedStyleForMultiline: consistent_comma
       #   # bad
@@ -37,6 +38,14 @@ module RuboCop
       #     2,
       #   ]
       #
+      #   # bad
+      #   a = [1, 2,
+      #        3, 4]
+      #
+      #   # good
+      #   a = [1, 2,
+      #        3, 4,]
+      #
       # @example EnforcedStyleForMultiline: comma
       #   # bad
       #   a = [1, 2,]
@@ -72,6 +81,38 @@ module RuboCop
       #     2,
       #   ]
       #
+      # @example EnforcedStyleForMultiline: diff_comma
+      #   # bad
+      #   a = [1, 2,]
+      #
+      #   # good
+      #   a = [1, 2]
+      #
+      #   # good
+      #   a = [
+      #     1, 2,
+      #     3,
+      #   ]
+      #
+      #   # good
+      #   a = [
+      #     1, 2, 3,
+      #   ]
+      #
+      #   # good
+      #   a = [
+      #     1,
+      #     2,
+      #   ]
+      #
+      #   # bad
+      #   a = [1, 2,
+      #        3, 4,]
+      #
+      #   # good
+      #   a = [1, 2,
+      #        3, 4]
+      #
       # @example EnforcedStyleForMultiline: no_comma (default)
       #   # bad
       #   a = [1, 2,]

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

@@ -6,12 +6,13 @@ module RuboCop
       # Checks for trailing comma in hash literals.
       # The configuration options are:
       #
-      # * `consistent_comma`: Requires a comma after the
-      # last item of all non-empty, multiline hash literals.
-      # * `comma`: Requires a comma after the last item in a hash,
-      # but only when each item is on its own line.
-      # * `no_comma`: Does not require a comma after the
-      # last item in a hash
+      # * `consistent_comma`: Requires a comma after the last item of all non-empty, multiline hash
+      # literals.
+      # * `comma`: Requires a comma after the last item in a hash, but only when each item is on its
+      # own line.
+      # * `diff_comma`: Requires a comma after the last item in a hash, but only when that item is
+      # followed by an immediate newline.
+      # * `no_comma`: Does not require a comma after the last item in a hash
       #
       # @example EnforcedStyleForMultiline: consistent_comma
       #
@@ -38,6 +39,14 @@ module RuboCop
       #     bar: 2,
       #   }
       #
+      #   # bad
+      #   a = { foo: 1, bar: 2,
+      #         baz: 3, qux: 4 }
+      #
+      #   # good
+      #   a = { foo: 1, bar: 2,
+      #         baz: 3, qux: 4, }
+      #
       # @example EnforcedStyleForMultiline: comma
       #
       #   # bad
@@ -74,6 +83,39 @@ module RuboCop
       #     bar: 2,
       #   }
       #
+      # @example EnforcedStyleForMultiline: diff_comma
+      #
+      #   # bad
+      #   a = { foo: 1, bar: 2, }
+      #
+      #   # good
+      #   a = { foo: 1, bar: 2 }
+      #
+      #   # good
+      #   a = {
+      #     foo: 1, bar: 2,
+      #     qux: 3,
+      #   }
+      #
+      #   # good
+      #   a = {
+      #     foo: 1, bar: 2, qux: 3,
+      #   }
+      #
+      #   # good
+      #   a = {
+      #     foo: 1,
+      #     bar: 2,
+      #   }
+      #
+      #   # bad
+      #   a = { foo: 1, bar: 2,
+      #         baz: 3, qux: 4, }
+      #
+      #   # good
+      #   a = { foo: 1, bar: 2,
+      #         baz: 3, qux: 4 }
+      #
       # @example EnforcedStyleForMultiline: no_comma (default)
       #
       #   # bad

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

@@ -113,7 +113,7 @@ module RuboCop
         private
 
         def in_module_or_instance_eval?(node)
-          node.each_ancestor(:block, :class, :sclass, :module).each do |pnode|
+          node.each_ancestor(:any_block, :class, :sclass, :module).each do |pnode|
             case pnode.type
             when :class, :sclass
               return false

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/style/while_until_modifier.rb

@@ -24,7 +24,6 @@ module RuboCop
       #   # good
       #   x += 1 until x > 10
       #
-      # @example
       #   # bad
       #   x += 100 while x < 500 # a long comment that makes code too long if it were a single line
       #

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

@@ -85,6 +85,12 @@ module RuboCop
         NONCOMMUTATIVE_OPERATORS = %i[===].freeze
         PROGRAM_NAMES = %i[$0 $PROGRAM_NAME].freeze
         RESTRICT_ON_SEND = RuboCop::AST::Node::COMPARISON_OPERATORS
+        ENFORCE_YODA_STYLES = %i[
+          require_for_all_comparison_operators require_for_equality_operators_only
+        ].freeze
+        EQUALITY_ONLY_STYLES = %i[
+          forbid_for_equality_operators_only require_for_equality_operators_only
+        ].freeze
 
         # @!method file_constant_equal_program_name?(node)
         def_node_matcher :file_constant_equal_program_name?, <<~PATTERN
@@ -105,13 +111,11 @@ module RuboCop
         private
 
         def enforce_yoda?
-          style == :require_for_all_comparison_operators ||
-            style == :require_for_equality_operators_only
+          ENFORCE_YODA_STYLES.include?(style)
         end
 
         def equality_only?
-          style == :forbid_for_equality_operators_only ||
-            style == :require_for_equality_operators_only
+          EQUALITY_ONLY_STYLES.include?(style)
         end
 
         def yoda_compatible_condition?(node)

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

@@ -50,6 +50,7 @@ module RuboCop
 
         def on_send(node)
           return unless supported_operators.include?(node.method_name.to_s)
+          return unless node.arguments?
 
           lhs = node.receiver
           rhs = node.first_argument
@@ -71,7 +72,7 @@ module RuboCop
         end
 
         def constant_portion?(node)
-          node.numeric_type? || node.const_type?
+          node.type?(:numeric, :const)
         end
 
         def supported_operators

data/lib/rubocop/cop/util.rb

@@ -32,7 +32,7 @@ module RuboCop
       end
 
       def parentheses?(node)
-        node.loc.respond_to?(:end) && node.loc.end&.is?(')')
+        node.loc_is?(:end, ')')
       end
 
       # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
@@ -74,9 +74,9 @@ module RuboCop
 
       def args_begin(node)
         loc = node.loc
-        selector = if node.super_type? || node.yield_type?
+        selector = if node.type?(:super, :yield)
                      loc.keyword
-                   elsif node.def_type? || node.defs_type?
+                   elsif node.type?(:def, :defs)
                      loc.name
                    else
                      loc.selector
@@ -193,11 +193,18 @@ module RuboCop
           enforced_style.sub(/^Enforced/, 'Supported').sub('Style', 'Styles')
       end
 
+      def parse_regexp(text)
+        Regexp::Parser.parse(text)
+      rescue Regexp::Parser::Error
+        # Upon encountering an invalid regular expression,
+        # we aim to proceed and identify any remaining potential offenses.
+        nil
+      end
+
       private
 
       def compatible_external_encoding_for?(src)
-        src = src.dup if RUBY_ENGINE == 'jruby'
-        src.force_encoding(Encoding.default_external).valid_encoding?
+        src.dup.force_encoding(Encoding.default_external).valid_encoding?
       end
 
       def include_or_equal?(source, target)

data/lib/rubocop/cop/utils/format_string.rb

@@ -5,15 +5,16 @@ module RuboCop
     module Utils
       # Parses {Kernel#sprintf} format strings.
       class FormatString
-        DIGIT_DOLLAR  = /(\d+)\$/.freeze
+        DIGIT_DOLLAR  = /(?<arg_number>\d+)\$/.freeze
+        INTERPOLATION = /#\{.*?\}/.freeze
         FLAG          = /[ #0+-]|#{DIGIT_DOLLAR}/.freeze
         NUMBER_ARG    = /\*#{DIGIT_DOLLAR}?/.freeze
-        NUMBER        = /\d+|#{NUMBER_ARG}/.freeze
+        NUMBER        = /\d+|#{NUMBER_ARG}|#{INTERPOLATION}/.freeze
         WIDTH         = /(?<width>#{NUMBER})/.freeze
-        PRECISION     = /\.(?<precision>#{NUMBER})/.freeze
+        PRECISION     = /\.(?<precision>#{NUMBER}?)/.freeze
         TYPE          = /(?<type>[bBdiouxXeEfgGaAcps])/.freeze
         NAME          = /<(?<name>\w+)>/.freeze
-        TEMPLATE_NAME = /\{(?<name>\w+)\}/.freeze
+        TEMPLATE_NAME = /(?<!#)\{(?<name>\w+)\}/.freeze
 
         SEQUENCE = /
             % (?<type>%)
@@ -41,7 +42,7 @@ module RuboCop
         #
         # @see https://ruby-doc.org/core-2.6.3/Kernel.html#method-i-format
         class FormatSequence
-          attr_reader :begin_pos, :end_pos, :flags, :width, :precision, :name, :type
+          attr_reader :begin_pos, :end_pos, :flags, :width, :precision, :name, :type, :arg_number
 
           def initialize(match)
             @source = match[0]
@@ -52,6 +53,7 @@ module RuboCop
             @precision = match[:precision]
             @name = match[:name]
             @type = match[:type]
+            @arg_number = match[:arg_number]
           end
 
           def percent?

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

@@ -6,6 +6,8 @@ module RuboCop
       # A Variable represents existence of a local variable.
       # This holds a variable declaration node and some states of the variable.
       class Variable
+        extend NodePattern::Macros
+
         VARIABLE_DECLARATION_TYPES = (VARIABLE_ASSIGNMENT_TYPES + ARGUMENT_DECLARATION_TYPES).freeze
 
         attr_reader :name, :declaration_node, :scope, :assignments, :references, :captured_by_block
@@ -29,9 +31,23 @@ module RuboCop
         end
 
         def assign(node)
-          @assignments << Assignment.new(node, self)
+          assignment = Assignment.new(node, self)
+
+          mark_last_as_reassigned!(assignment)
+
+          @assignments << assignment
         end
 
+        def mark_last_as_reassigned!(assignment)
+          return if captured_by_block?
+          return if candidate_condition?(assignment.node.parent)
+
+          @assignments.last&.reassigned!
+        end
+
+        # @!method candidate_condition?(node)
+        def_node_matcher :candidate_condition?, '[{if case case_match when}]'
+
         def referenced?
           !@references.empty?
         end
@@ -68,7 +84,7 @@ module RuboCop
           parent = parent.parent if parent&.begin_type?
           return false if parent.nil?
 
-          (parent.if_type? || parent.while_type? || parent.until_type?) && parent.modifier_form?
+          parent.type?(:if, :while, :until) && parent.modifier_form?
         end
 
         def capture_with_block!

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)
@@ -100,7 +100,7 @@ module RuboCop
 
             # Only block scope allows referencing outer scope variables.
             node = scope.node
-            return nil unless node.block_type? || node.numblock_type?
+            return nil unless node.any_block_type?
           end
 
           nil
@@ -113,14 +113,14 @@ module RuboCop
         def accessible_variables
           scope_stack.reverse_each.with_object([]) do |scope, variables|
             variables.concat(scope.variables.values)
-            break variables unless scope.node.block_type? || scope.node.numblock_type?
+            break variables unless scope.node.any_block_type?
           end
         end
 
         private
 
         def mark_variable_as_captured_by_block_if_so(variable)
-          return unless current_scope.node.block_type? || current_scope.node.numblock_type?
+          return unless current_scope.node.any_block_type?
           return if variable.scope == current_scope
 
           variable.capture_with_block!

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