rubocop 1.68.0 → 1.69.0

data/lib/rubocop/cop/layout/multiline_method_definition_brace_layout.rb

@@ -12,7 +12,7 @@ module RuboCop
       # first parameter of the definition, then the closing brace should be
       # on the same line as the last parameter of the definition.
       #
-      # If an method definition's opening brace is on the line above the first
+      # If a method definition's opening brace is on the line above the first
       # parameter of the definition, then the closing brace should be on the
       # line below the last parameter of the definition.
       #

data/lib/rubocop/cop/layout/multiline_operation_indentation.rb

@@ -76,9 +76,8 @@ module RuboCop
         end
 
         def check_and_or(node)
-          lhs, rhs = *node
-          range = offending_range(node, lhs, rhs.source_range, style)
-          check(range, node, lhs, rhs.source_range)
+          range = offending_range(node, node.lhs, node.rhs.source_range, style)
+          check(range, node, node.lhs, node.rhs.source_range)
         end
 
         def offending_range(node, lhs, rhs, given_style)

data/lib/rubocop/cop/layout/parameter_alignment.rb

@@ -3,11 +3,10 @@
 module RuboCop
   module Cop
     module Layout
-      # Here we check if the parameters on a multi-line method call or
-      # definition are aligned.
+      # Check that the parameters on a multi-line method call or definition are aligned.
       #
-      # To set the alignment of the first argument, use the cop
-      # FirstParameterIndentation.
+      # To set the alignment of the first argument, use the
+      # `Layout/FirstParameterIndentation` cop.
       #
       # @example EnforcedStyle: with_first_parameter (default)
       #   # good

data/lib/rubocop/cop/layout/redundant_line_break.rb

@@ -44,6 +44,7 @@ module RuboCop
       #
       class RedundantLineBreak < Base
         include CheckAssignment
+        include CheckSingleLineSuitability
         extend AutoCorrector
 
         MSG = 'Redundant line break detected.'
@@ -84,8 +85,8 @@ module RuboCop
         end
 
         def offense?(node)
-          return false if !node.multiline? || too_long?(node) || !suitable_as_single_line?(node)
-          return require_backslash?(node) if node.and_type? || node.or_type?
+          return false unless node.multiline? && suitable_as_single_line?(node)
+          return require_backslash?(node) if node.operator_keyword?
 
           !index_access_call_chained?(node) && !configured_to_not_be_inspected?(node)
         end
@@ -117,44 +118,11 @@ module RuboCop
           @config.for_cop('Layout/SingleLineBlockChain')['Enabled']
         end
 
-        def suitable_as_single_line?(node)
-          !comment_within?(node) &&
-            node.each_descendant(:if, :case, :kwbegin, :def, :defs).none? &&
-            node.each_descendant(:dstr, :str).none? { |n| n.heredoc? || n.value.include?("\n") } &&
-            node.each_descendant(:begin, :sym).none? { |b| !b.single_line? }
-        end
-
         def convertible_block?(node)
           parent = node.parent
           parent&.block_type? && node == parent.send_node &&
             (node.parenthesized? || !node.arguments?)
         end
-
-        def comment_within?(node)
-          comment_line_numbers = processed_source.comments.map { |comment| comment.loc.line }
-
-          comment_line_numbers.any? do |comment_line_number|
-            comment_line_number >= node.first_line && comment_line_number <= node.last_line
-          end
-        end
-
-        def too_long?(node)
-          lines = processed_source.lines[(node.first_line - 1)...node.last_line]
-          to_single_line(lines.join("\n")).length > max_line_length
-        end
-
-        def to_single_line(source)
-          source
-            .gsub(/" *\\\n\s*'/, %q(" + ')) # Double quote, backslash, and then single quote
-            .gsub(/' *\\\n\s*"/, %q(' + ")) # Single quote, backslash, and then double quote
-            .gsub(/(["']) *\\\n\s*\1/, '')  # Double or single quote, backslash, then same quote
-            .gsub(/\n\s*(?=(&)?\.\w)/, '')  # Extra space within method chaining which includes `&.`
-            .gsub(/\s*\\?\n\s*/, ' ')       # Any other line break, with or without backslash
-        end
-
-        def max_line_length
-          config.for_cop('Layout/LineLength')['Max']
-        end
       end
     end
   end

data/lib/rubocop/cop/layout/rescue_ensure_alignment.rb

@@ -92,6 +92,7 @@ module RuboCop
           )
         end
 
+        # rubocop:disable Metrics/AbcSize
         def alignment_source(node, starting_loc)
           ending_loc =
             case node.type
@@ -101,8 +102,7 @@ module RuboCop
                  :lvasgn, :ivasgn, :cvasgn, :gvasgn, :casgn
               node.loc.name
             when :masgn
-              mlhs_node, = *node
-              mlhs_node.source_range
+              node.lhs.source_range
             else
               # It is a wrapper with receiver of object attribute or access modifier.
               node.receiver&.source_range || node.child_nodes.first.loc.name
@@ -110,6 +110,7 @@ module RuboCop
 
           range_between(starting_loc.begin_pos, ending_loc.end_pos).source
         end
+        # rubocop:enable Metrics/AbcSize
 
         # We will use ancestor or wrapper with access modifier.
 

data/lib/rubocop/cop/layout/space_around_keyword.rb

@@ -256,7 +256,7 @@ module RuboCop
           # regular dotted method calls bind more tightly than operators
           # so we need to climb up the AST past them
           node.each_ancestor do |ancestor|
-            return true if ancestor.and_type? || ancestor.or_type? || ancestor.range_type?
+            return true if ancestor.operator_keyword? || ancestor.range_type?
             return false unless ancestor.send_type?
             return true if ancestor.operator_method?
           end

data/lib/rubocop/cop/layout/space_around_operators.rb

@@ -99,51 +99,50 @@ module RuboCop
         def on_resbody(node)
           return unless node.loc.assoc
 
-          _, variable, = *node
-
-          check_operator(:resbody, node.loc.assoc, variable)
+          check_operator(:resbody, node.loc.assoc, node.exception_variable)
         end
 
         def on_send(node)
           return if rational_literal?(node)
 
           if node.setter_method?
-            on_special_asgn(node)
+            on_setter_method(node)
           elsif regular_operator?(node)
             check_operator(:send, node.loc.selector, node.first_argument)
           end
         end
 
         def on_assignment(node)
-          _, rhs, = *node
+          rhs = node.rhs
 
           return unless rhs
 
-          check_operator(:assignment, node.loc.operator, rhs)
+          type = node.op_asgn_type? ? :special_asgn : :assignment
+          check_operator(type, node.loc.operator, rhs)
         end
 
-        def on_casgn(node)
-          _, _, right, = *node
+        def on_class(node)
+          rhs = node.parent_class
 
-          return unless right
+          return unless rhs
 
-          check_operator(:assignment, node.loc.operator, right)
+          check_operator(:class, node.loc.operator, rhs)
         end
 
         def on_binary(node)
-          _, rhs, = *node
+          rhs = node.rhs
 
           return unless rhs
 
           check_operator(:binary, node.loc.operator, rhs)
         end
 
-        def on_special_asgn(node)
-          _, _, right, = *node
+        def on_setter_method(node)
+          rhs = node.first_argument
 
-          return unless right
+          return unless rhs
 
-          check_operator(:special_asgn, node.loc.operator, right)
+          check_operator(:special_asgn, node.loc.operator, node.first_argument)
         end
 
         def on_match_pattern(node)
@@ -155,14 +154,14 @@ module RuboCop
         alias on_or       on_binary
         alias on_and      on_binary
         alias on_lvasgn   on_assignment
+        alias on_casgn    on_assignment
         alias on_masgn    on_assignment
         alias on_ivasgn   on_assignment
         alias on_cvasgn   on_assignment
         alias on_gvasgn   on_assignment
-        alias on_class    on_binary
         alias on_or_asgn  on_assignment
         alias on_and_asgn on_assignment
-        alias on_op_asgn  on_special_asgn
+        alias on_op_asgn  on_assignment
 
         private
 

data/lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb

@@ -12,9 +12,11 @@ module RuboCop
       #
       #   # bad
       #   array = [ a, b, c, d ]
+      #   array = [ a, [ b, c ]]
       #
       #   # good
       #   array = [a, b, c, d]
+      #   array = [a, [b, c]]
       #
       # @example EnforcedStyle: space
       #   # The `space` style enforces that array literals have
@@ -22,9 +24,11 @@ module RuboCop
       #
       #   # bad
       #   array = [a, b, c, d]
+      #   array = [ a, [ b, c ]]
       #
       #   # good
       #   array = [ a, b, c, d ]
+      #   array = [ a, [ b, c ] ]
       #
       # @example EnforcedStyle: compact
       #   # The `compact` style normally requires a space inside
@@ -32,6 +36,7 @@ module RuboCop
       #   # or right brackets are collapsed together in nested arrays.
       #
       #   # bad
+      #   array = [a, b, c, d]
       #   array = [ a, [ b, c ] ]
       #   array = [
       #     [ a ],
@@ -39,6 +44,7 @@ module RuboCop
       #   ]
       #
       #   # good
+      #   array = [ a, b, c, d ]
       #   array = [ a, [ b, c ]]
       #   array = [[ a ],
       #     [ b, c ]]

data/lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb

@@ -12,9 +12,11 @@ module RuboCop
       #
       #   # bad
       #   h = {a: 1, b: 2}
+      #   foo = {{ a: 1 } => { b: { c: 2 }}}
       #
       #   # good
       #   h = { a: 1, b: 2 }
+      #   foo = { { a: 1 } => { b: { c: 2 } } }
       #
       # @example EnforcedStyle: no_space
       #   # The `no_space` style enforces that hash literals have
@@ -22,9 +24,11 @@ module RuboCop
       #
       #   # bad
       #   h = { a: 1, b: 2 }
+      #   foo = {{ a: 1 } => { b: { c: 2 }}}
       #
       #   # good
       #   h = {a: 1, b: 2}
+      #   foo = {{a: 1} => {b: {c: 2}}}
       #
       # @example EnforcedStyle: compact
       #   # The `compact` style normally requires a space inside

data/lib/rubocop/cop/layout/space_inside_string_interpolation.rb

@@ -22,7 +22,6 @@ module RuboCop
         include Interpolation
         include SurroundingSpace
         include ConfigurableEnforcedStyle
-        include RangeHelp
         extend AutoCorrector
 
         MSG = '%<command>s space inside string interpolation.'

data/lib/rubocop/cop/lint/binary_operator_with_identical_operands.rb

@@ -5,17 +5,16 @@ module RuboCop
     module Lint
       # Checks for places where binary operator has identical operands.
       #
-      # It covers arithmetic operators: `-`, `/`, `%`;
-      # comparison operators: `==`, `===`, `=~`, `>`, `>=`, `<`, ``<=``;
+      # It covers comparison operators: `==`, `===`, `=~`, `>`, `>=`, `<`, ``<=``;
       # bitwise operators: `|`, `^`, `&`;
       # boolean operators: `&&`, `||`
       # and "spaceship" operator - ``<=>``.
       #
       # Simple arithmetic operations are allowed by this cop: `+`, `*`, `**`, `<<` and `>>`.
       # Although these can be rewritten in a different way, it should not be necessary to
-      # do so. This does not include operations such as `-` or `/` where the result will
-      # always be the same (`x - x` will always be 0; `x / x` will always be 1), and
-      # thus are legitimate offenses.
+      # do so. Operations such as `-` or `/` where the result will always be the same
+      # (`x - x` will always be 0; `x / x` will always be 1) are offenses, but these
+      # are covered by Lint/NumericOperationWithConstantResult instead.
       #
       # @safety
       #   This cop is unsafe as it does not consider side effects when calling methods
@@ -30,7 +29,6 @@ module RuboCop
       #
       # @example
       #   # bad
-      #   x / x
       #   x.top >= x.top
       #
       #   if a.x != 0 && a.x != 0
@@ -47,19 +45,20 @@ module RuboCop
       #
       class BinaryOperatorWithIdenticalOperands < Base
         MSG = 'Binary operator `%<op>s` has identical operands.'
-        ALLOWED_MATH_OPERATORS = %i[+ * ** << >>].to_set.freeze
+        MATH_OPERATORS = %i[- + * / ** << >>].to_set.freeze
 
         def on_send(node)
           return unless node.binary_operation?
+          return if MATH_OPERATORS.include?(node.method_name)
+          return unless node.receiver == node.first_argument
 
-          lhs, operation, rhs = *node
-          return if ALLOWED_MATH_OPERATORS.include?(node.method_name)
-
-          add_offense(node, message: format(MSG, op: operation)) if lhs == rhs
+          add_offense(node, message: format(MSG, op: node.method_name))
         end
 
         def on_and(node)
-          add_offense(node, message: format(MSG, op: node.operator)) if node.lhs == node.rhs
+          return unless node.lhs == node.rhs
+
+          add_offense(node, message: format(MSG, op: node.operator))
         end
         alias on_or on_and
       end

data/lib/rubocop/cop/lint/circular_argument_reference.rb

@@ -8,6 +8,8 @@ module RuboCop
       #
       # This cop mirrors a warning produced by MRI since 2.2.
       #
+      # NOTE: This syntax is no longer valid on Ruby 2.7 or higher.
+      #
       # @example
       #
       #   # bad

data/lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb

@@ -51,7 +51,7 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return if node.arguments.any? { |arg| arg.variable? || arg.send_type? || arg.const_type? }
+          return if node.arguments.any? { |arg| arg.variable? || arg.call_type? || arg.const_type? }
           return if digest_const?(node.receiver)
           return unless algorithm_const(node)
 

data/lib/rubocop/cop/lint/empty_ensure.rb

@@ -38,7 +38,7 @@ module RuboCop
         MSG = 'Empty `ensure` block detected.'
 
         def on_ensure(node)
-          return if node.body
+          return if node.branch
 
           add_offense(node.loc.keyword) { |corrector| corrector.remove(node.loc.keyword) }
         end

data/lib/rubocop/cop/lint/empty_file.rb

@@ -21,8 +21,6 @@ module RuboCop
       #   # File consisting only of comments
       #
       class EmptyFile < Base
-        include RangeHelp
-
         MSG = 'Empty file detected.'
 
         def on_new_investigation

data/lib/rubocop/cop/lint/ensure_return.rb

@@ -43,7 +43,7 @@ module RuboCop
         MSG = 'Do not return from an `ensure` block.'
 
         def on_ensure(node)
-          node.body&.each_node(:return) { |return_node| add_offense(return_node) }
+          node.branch&.each_node(:return) { |return_node| add_offense(return_node) }
         end
       end
     end

data/lib/rubocop/cop/lint/float_comparison.rb

@@ -29,6 +29,9 @@ module RuboCop
       #   tolerance = 0.0001
       #   (x - 0.1).abs < tolerance
       #
+      #   # good - comparing against nil
+      #   Float(x, exception: false) == nil
+      #
       #   # Or some other epsilon based type of comparison:
       #   # https://www.embeddeduse.com/2019/08/26/qt-compare-two-floats/
       #
@@ -42,8 +45,12 @@ module RuboCop
         RESTRICT_ON_SEND = EQUALITY_METHODS
 
         def on_send(node)
-          lhs, _method, rhs = *node
-          return if literal_zero?(lhs) || literal_zero?(rhs)
+          return unless node.arguments.one?
+
+          lhs = node.receiver
+          rhs = node.first_argument
+
+          return if literal_safe?(lhs) || literal_safe?(rhs)
 
           add_offense(node) if float?(lhs) || float?(rhs)
         end
@@ -65,15 +72,16 @@ module RuboCop
           end
         end
 
-        def literal_zero?(node)
-          node&.numeric_type? && node.value.zero?
+        def literal_safe?(node)
+          return false unless node
+
+          (node.numeric_type? && node.value.zero?) || node.nil_type?
         end
 
         # rubocop:disable Metrics/PerceivedComplexity
         def check_send(node)
           if node.arithmetic_operation?
-            lhs, _operation, rhs = *node
-            float?(lhs) || float?(rhs)
+            float?(node.receiver) || float?(node.first_argument)
           elsif FLOAT_RETURNING_METHODS.include?(node.method_name)
             true
           elsif node.receiver&.float_type?

data/lib/rubocop/cop/lint/float_out_of_range.rb

@@ -18,9 +18,7 @@ module RuboCop
         MSG = 'Float out of range.'
 
         def on_float(node)
-          value, = *node
-
-          return unless value.infinite? || (value.zero? && /[1-9]/.match?(node.source))
+          return unless node.value.infinite? || (node.value.zero? && /[1-9]/.match?(node.source))
 
           add_offense(node)
         end

data/lib/rubocop/cop/lint/hash_new_with_keyword_arguments_as_default.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for the deprecated use of keyword arguments as a default in `Hash.new`.
+      #
+      # This usage raises a warning in Ruby 3.3 and results in an error in Ruby 3.4.
+      # In Ruby 3.4, keyword arguments will instead be used to change the behavior of a hash.
+      # For example, the capacity option can be passed to create a hash with a certain size
+      # if you know it in advance, for better performance.
+      #
+      # NOTE: The following corner case may result in a false negative when upgrading from Ruby 3.3
+      # or earlier, but it is intentionally not detected to respect the expected usage in Ruby 3.4.
+      #
+      # [source,ruby]
+      # ----
+      # Hash.new(capacity: 42)
+      # ----
+      #
+      # @example
+      #
+      #   # bad
+      #   Hash.new(key: :value)
+      #
+      #   # good
+      #   Hash.new({key: :value})
+      #
+      class HashNewWithKeywordArgumentsAsDefault < Base
+        extend AutoCorrector
+
+        MSG = 'Use a hash literal instead of keyword arguments.'
+        RESTRICT_ON_SEND = %i[new].freeze
+
+        # @!method hash_new(node)
+        def_node_matcher :hash_new, <<~PATTERN
+          (send (const {nil? (cbase)} :Hash) :new $[hash !braces?])
+        PATTERN
+
+        def on_send(node)
+          return unless (first_argument = hash_new(node))
+
+          if first_argument.pairs.one?
+            key = first_argument.pairs.first.key
+            return if key.respond_to?(:value) && key.value == :capacity
+          end
+
+          add_offense(first_argument) do |corrector|
+            corrector.wrap(first_argument, '{', '}')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/interpolation_check.rb

@@ -24,14 +24,17 @@ module RuboCop
         MSG = 'Interpolation in single quoted string detected. ' \
               'Use double quoted strings if you need interpolation.'
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def on_str(node)
           return if node.parent&.regexp_type?
           return unless /(?<!\\)#\{.*\}/.match?(node.source)
           return if heredoc?(node)
           return unless node.loc.begin && node.loc.end
+          return unless valid_syntax?(node)
 
           add_offense(node) { |corrector| autocorrect(corrector, node) }
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         private
 
@@ -49,6 +52,12 @@ module RuboCop
         def heredoc?(node)
           node.loc.is_a?(Parser::Source::Map::Heredoc) || (node.parent && heredoc?(node.parent))
         end
+
+        def valid_syntax?(node)
+          double_quoted_string = node.source.gsub(/\A'|'\z/, '"')
+
+          parse(double_quoted_string).valid_syntax?
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/it_without_arguments_in_block.rb

@@ -26,6 +26,9 @@ module RuboCop
       #
       class ItWithoutArgumentsInBlock < Base
         include NodePattern::Macros
+        extend TargetRubyVersion
+
+        maximum_target_ruby_version 3.3
 
         MSG = '`it` calls without arguments will refer to the first block param in Ruby 3.4; ' \
               'use `it()` or `self.it`.'

data/lib/rubocop/cop/lint/literal_assignment_in_condition.rb

@@ -40,7 +40,7 @@ module RuboCop
           traverse_node(node.condition) do |asgn_node|
             next unless asgn_node.loc.operator
 
-            rhs = asgn_node.to_a.last
+            rhs = asgn_node.rhs
             next if !all_literals?(rhs) || parallel_assignment_with_splat_operator?(rhs)
 
             range = offense_range(asgn_node, rhs)

data/lib/rubocop/cop/lint/mixed_case_range.rb

@@ -36,12 +36,9 @@ module RuboCop
 
         def on_irange(node)
           return unless node.children.compact.all?(&:str_type?)
+          return if node.begin.nil? || node.end.nil?
 
-          range_start, range_end = node.children
-
-          return if range_start.nil? || range_end.nil?
-
-          add_offense(node) if unsafe_range?(range_start.value, range_end.value)
+          add_offense(node) if unsafe_range?(node.begin.value, node.end.value)
         end
         alias on_erange on_irange
 

data/lib/rubocop/cop/lint/nested_method_definition.rb

@@ -95,7 +95,7 @@ module RuboCop
         MSG = 'Method definitions must not be nested. Use `lambda` instead.'
 
         def on_def(node)
-          subject, = *node
+          subject, = *node # rubocop:disable InternalAffairs/NodeDestructuring
           return if node.defs_type? && subject.variable?
 
           def_ancestor = node.each_ancestor(:def, :defs).first

data/lib/rubocop/cop/lint/no_return_in_begin_end_blocks.rb

@@ -45,8 +45,8 @@ module RuboCop
             end
           end
         end
-        alias on_or_asgn    on_lvasgn
-        alias on_op_asgn    on_lvasgn
+        alias on_or_asgn on_lvasgn
+        alias on_op_asgn on_lvasgn
       end
     end
   end

data/lib/rubocop/cop/lint/non_atomic_file_operation.rb

@@ -95,7 +95,7 @@ module RuboCop
         end
 
         def allowable_use_with_if?(if_node)
-          if_node.condition.and_type? || if_node.condition.or_type? || if_node.else_branch
+          if_node.condition.operator_keyword? || if_node.else_branch
         end
 
         def register_offense(node, exist_node)

data/lib/rubocop/cop/lint/number_conversion.rb

@@ -74,7 +74,6 @@ module RuboCop
         extend AutoCorrector
         include AllowedMethods
         include AllowedPattern
-        include IgnoredNode
 
         CONVERSION_METHOD_CLASS_MAPPING = {
           to_i: "#{Integer.name}(%<number_object>s, 10)",

data/lib/rubocop/cop/lint/numbered_parameter_assignment.rb

@@ -33,8 +33,7 @@ module RuboCop
         NUMBERED_PARAMETER_RANGE = (1..9).freeze
 
         def on_lvasgn(node)
-          lhs, _rhs = *node
-          return unless /\A_(\d+)\z/ =~ lhs
+          return unless /\A_(\d+)\z/ =~ node.name
 
           number = Regexp.last_match(1).to_i
           template = NUMBERED_PARAMETER_RANGE.include?(number) ? NUM_PARAM_MSG : LVAR_MSG