rubocop 1.67.0 → 1.75.5

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
 
@@ -243,12 +242,12 @@ module RuboCop
           return !aligned_with_operator?(operator) unless type == :assignment
 
           token            = Token.new(operator, nil, operator.source)
-          align_preceding  = aligned_with_preceding_assignment(token)
+          align_preceding  = aligned_with_preceding_equals_operator(token)
 
           return false if align_preceding == :yes ||
-                          aligned_with_subsequent_assignment(token) == :none
+                          aligned_with_subsequent_equals_operator(token) == :none
 
-          aligned_with_subsequent_assignment(token) != :yes
+          aligned_with_subsequent_equals_operator(token) != :yes
         end
 
         def excess_trailing_space?(right_operand, with_space)
@@ -261,7 +260,10 @@ module RuboCop
         end
 
         def hash_table_style?
-          align_hash_cop_config && align_hash_cop_config['EnforcedHashRocketStyle'] == 'table'
+          return false unless align_hash_cop_config
+
+          enforced_styles = Array(align_hash_cop_config['EnforcedHashRocketStyle'])
+          enforced_styles.include?('table')
         end
 
         def space_around_exponent_operator?

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

@@ -77,6 +77,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 

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

@@ -33,12 +33,12 @@ module RuboCop
         private
 
         def offense_range(node, begin_pos)
-          if reference_variable_with_brackets?(node)
-            receiver_end_pos = node.receiver.source_range.end_pos
-            selector_begin_pos = node.loc.selector.begin_pos
-            return if receiver_end_pos >= selector_begin_pos
-            return if dot_before_brackets?(node, receiver_end_pos, selector_begin_pos)
+          receiver_end_pos = node.receiver.source_range.end_pos
+          selector_begin_pos = node.loc.selector.begin_pos
+          return if receiver_end_pos >= selector_begin_pos
+          return if dot_before_brackets?(node, receiver_end_pos, selector_begin_pos)
 
+          if reference_variable_with_brackets?(node)
             range_between(receiver_end_pos, selector_begin_pos)
           elsif node.method?(:[]=)
             offense_range_for_assignment(node, begin_pos)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # Checks for comma (,) preceded by space.
+      # Checks for comma (`,`) preceded by space.
       #
       # @example
       #   # bad

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # Checks for semicolon (;) preceded by space.
+      # Checks for semicolon (`;`) preceded by space.
       #
       # @example
       #   # bad

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

@@ -6,15 +6,19 @@ module RuboCop
       # Checks that brackets used for array literals have or don't have
       # surrounding space depending on configuration.
       #
+      # Array pattern matching is handled in the same way.
+      #
       # @example EnforcedStyle: no_space (default)
       #   # The `no_space` style enforces that array literals have
       #   # no surrounding space.
       #
       #   # 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 +26,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 +38,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 +46,7 @@ module RuboCop
       #   ]
       #
       #   # good
+      #   array = [ a, b, c, d ]
       #   array = [ a, [ b, c ]]
       #   array = [[ a ],
       #     [ b, c ]]
@@ -76,7 +84,7 @@ module RuboCop
         EMPTY_MSG = '%<command>s space inside empty array brackets.'
 
         def on_array(node)
-          return unless node.square_brackets?
+          return if node.array_type? && !node.square_brackets?
 
           tokens, left, right = array_brackets(node)
 
@@ -89,6 +97,7 @@ module RuboCop
 
           issue_offenses(node, left, right, start_ok, end_ok)
         end
+        alias on_array_pattern on_array
 
         private
 

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

@@ -82,6 +82,10 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
+        def self.autocorrect_incompatible_with
+          [Style::BlockDelimiters]
+        end
+
         def on_block(node)
           return if node.keywords?
 
@@ -99,6 +103,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 

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

@@ -6,15 +6,19 @@ module RuboCop
       # Checks that braces used for hash literals have or don't have
       # surrounding space depending on configuration.
       #
+      # Hash pattern matching is handled in the same way.
+      #
       # @example EnforcedStyle: space (default)
       #   # The `space` style enforces that hash literals have
       #   # surrounding space.
       #
       #   # 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 +26,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
@@ -83,6 +89,7 @@ module RuboCop
           check(tokens[-2], tokens[-1]) if tokens.size > 2
           check_whitespace_only_hash(node) if enforce_no_space_style_for_empty_braces?
         end
+        alias on_hash_pattern on_hash
 
         private
 

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/layout/trailing_whitespace.rb

@@ -48,7 +48,7 @@ module RuboCop
 
         def on_new_investigation
           processed_source.lines.each_with_index do |line, index|
-            next unless line.end_with?(' ', "\t")
+            next unless line.match?(/[[:blank:]]\z/)
 
             process_line(line, index + 1)
           end
@@ -84,7 +84,7 @@ module RuboCop
         end
 
         def whitespace_is_indentation?(range, level)
-          range.source[/[ \t]+/].length <= level
+          range.source[/[[:blank:]]+/].length <= level
         end
 
         def whitespace_only?(range)
@@ -123,7 +123,9 @@ module RuboCop
         end
 
         def offense_range(lineno, line)
-          source_range(processed_source.buffer, lineno, (line.rstrip.length)...(line.length))
+          source_range(
+            processed_source.buffer, lineno, (line.sub(/[[:blank:]]+\z/, '').length)...(line.length)
+          )
         end
       end
     end

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

@@ -77,7 +77,7 @@ module RuboCop
         private
 
         def ambiguous_block_association?(send_node)
-          send_node.last_argument.block_type? && !send_node.last_argument.send_node.arguments?
+          send_node.last_argument.any_block_type? && !send_node.last_argument.send_node.arguments?
         end
 
         def allowed_method_pattern?(node)

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

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for an array literal interpolated inside a regexp.
+      #
+      # When interpolating an array literal, it is converted to a string. This means
+      # that when inside a regexp, it acts as a character class but with additional
+      # quotes, spaces and commas that are likely not intended. For example,
+      # `/#{%w[a b c]}/` parses as `/["a", "b", "c"]/` (or `/["a, bc]/` without
+      # repeated characters).
+      #
+      # The cop can autocorrect to a character class (if all items in the array are a
+      # single character) or alternation (if the array contains longer items).
+      #
+      # NOTE: This only considers interpolated arrays that contain only strings, symbols,
+      # integers, and floats. Any other type is not easily convertible to a character class
+      # or regexp alternation.
+      #
+      # @safety
+      #   Autocorrection is unsafe because it will change the regexp pattern, by
+      #   removing the additional quotes, spaces and commas from the character class.
+      #
+      # @example
+      #   # bad
+      #   /#{%w[a b c]}/
+      #
+      #   # good
+      #   /[abc]/
+      #
+      #   # bad
+      #   /#{%w[foo bar baz]}/
+      #
+      #   # good
+      #   /(?:foo|bar|baz)/
+      #
+      #   # bad - construct a regexp rather than interpolate an array of identifiers
+      #   /#{[foo, bar]}/
+      #
+      class ArrayLiteralInRegexp < Base
+        include Interpolation
+        extend AutoCorrector
+
+        LITERAL_TYPES = %i[str sym int float true false nil].freeze
+        private_constant :LITERAL_TYPES
+
+        MSG_CHARACTER_CLASS = 'Use a character class instead of interpolating an array in a regexp.'
+        MSG_ALTERNATION = 'Use alternation instead of interpolating an array in a regexp.'
+        MSG_UNKNOWN = 'Use alternation or a character class instead of interpolating an array ' \
+                      'in a regexp.'
+
+        def on_interpolation(begin_node)
+          return unless (final_node = begin_node.children.last)
+          return unless final_node.array_type?
+          return unless begin_node.parent.regexp_type?
+
+          if array_of_literal_values?(final_node)
+            register_array_of_literal_values(begin_node, final_node)
+          else
+            register_array_of_nonliteral_values(begin_node)
+          end
+        end
+
+        private
+
+        def array_of_literal_values?(node)
+          node.each_value.all? { |value| value.type?(*LITERAL_TYPES) }
+        end
+
+        def register_array_of_literal_values(begin_node, node)
+          array_values = array_values(node)
+
+          if character_class?(array_values)
+            message = MSG_CHARACTER_CLASS
+            replacement = character_class_for(array_values)
+          else
+            message = MSG_ALTERNATION
+            replacement = alternation_for(array_values)
+          end
+
+          add_offense(begin_node, message: message) do |corrector|
+            corrector.replace(begin_node, replacement)
+          end
+        end
+
+        def register_array_of_nonliteral_values(node)
+          # Add offense but do not correct if the array contains any nonliteral values.
+          add_offense(node, message: MSG_UNKNOWN)
+        end
+
+        def array_values(node)
+          node.each_value.map do |value|
+            value.respond_to?(:value) ? value.value : value.source
+          end
+        end
+
+        def character_class?(values)
+          values.all? { |v| v.to_s.length == 1 }
+        end
+
+        def character_class_for(values)
+          "[#{escape_values(values).join}]"
+        end
+
+        def alternation_for(values)
+          "(?:#{escape_values(values).join('|')})"
+        end
+
+        def escape_values(values)
+          # This may add extraneous escape characters, but they can be cleaned up
+          # by `Style/RedundantRegexpEscape`.
+          values.map { |value| Regexp.escape(value.to_s) }
+        end
+      end
+    end
+  end
+end

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

@@ -53,8 +53,6 @@ module RuboCop
         ASGN_TYPES = [:begin, *AST::Node::EQUALS_ASSIGNMENTS, :send, :csend].freeze
 
         def on_if(node)
-          return if node.condition.block_type?
-
           traverse_node(node.condition) do |asgn_node|
             next :skip_children if skip_children?(asgn_node)
             next if allowed_construct?(asgn_node)
@@ -95,7 +93,7 @@ module RuboCop
 
         def traverse_node(node, &block)
           # if the node is a block, any assignments are irrelevant
-          return if node.block_type?
+          return if node.any_block_type?
 
           result = yield node if ASGN_TYPES.include?(node.type)
 

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,19 @@ module RuboCop
       #
       class BinaryOperatorWithIdenticalOperands < Base
         MSG = 'Binary operator `%<op>s` has identical operands.'
-        ALLOWED_MATH_OPERATORS = %i[+ * ** << >>].to_set.freeze
+        RESTRICT_ON_SEND = %i[== != === <=> =~ && || > >= < <= | ^].freeze
 
         def on_send(node)
           return unless node.binary_operation?
+          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/boolean_symbol.rb

@@ -48,7 +48,7 @@ module RuboCop
         def autocorrect(corrector, node)
           boolean_literal = node.source.delete(':')
           parent = node.parent
-          if parent&.pair_type? && node.equal?(parent.children[0])
+          if parent&.pair_type? && parent.colon? && node.equal?(parent.children[0])
             corrector.remove(parent.loc.operator)
             boolean_literal = "#{node.source} =>"
           end

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

@@ -6,7 +6,8 @@ module RuboCop
       # Checks for circular argument references in optional keyword
       # arguments and optional ordinal arguments.
       #
-      # This cop mirrors a warning produced by MRI since 2.2.
+      # NOTE: This syntax was made invalid on Ruby 2.7 - Ruby 3.3 but is allowed
+      # again since Ruby 3.4.
       #
       # @example
       #
@@ -35,6 +36,8 @@ module RuboCop
       #     dry_ingredients.combine
       #   end
       class CircularArgumentReference < Base
+        extend TargetRubyVersion
+
         MSG = 'Circular argument reference - `%<arg_name>s`.'
 
         def on_kwoptarg(node)

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

@@ -68,12 +68,12 @@ module RuboCop
 
         # @!method constant_assigned_in_block?(node)
         def_node_matcher :constant_assigned_in_block?, <<~PATTERN
-          ({^block_type? [^begin_type? ^^block_type?]} nil? ...)
+          ({^any_block [^begin ^^any_block]} nil? ...)
         PATTERN
 
         # @!method module_defined_in_block?(node)
         def_node_matcher :module_defined_in_block?, <<~PATTERN
-          ({^block_type? [^begin_type? ^^block_type?]} ...)
+          ({^any_block [^begin ^^any_block]} ...)
         PATTERN
 
         def on_casgn(node)
@@ -92,7 +92,7 @@ module RuboCop
         private
 
         def method_name(node)
-          node.ancestors.find(&:block_type?).method_name
+          node.ancestors.find(&:any_block_type?).method_name
         end
       end
     end