rubocop 1.69.2 → 1.75.4

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

@@ -101,7 +101,7 @@ module RuboCop
               ranges << loc.expression
             elsif literal.heredoc?
               ranges << loc.heredoc_body
-            elsif loc.respond_to?(:begin) && loc.begin
+            elsif (loc.respond_to?(:begin) && loc.begin) || ignored_parent?(literal)
               ranges << loc.expression
             end
           end
@@ -127,6 +127,12 @@ module RuboCop
                               comment_ranges(processed_source.comments)
         end
 
+        def ignored_parent?(node)
+          return false unless node.parent
+
+          node.parent.type?(:regexp, :xstr)
+        end
+
         def no_space_style?
           cop_config['EnforcedStyle'] == 'no_space'
         end

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

@@ -102,7 +102,7 @@ module RuboCop
 
         def strings_concatenated_with_backslash?(dstr_node)
           dstr_node.multiline? &&
-            dstr_node.children.all? { |c| c.str_type? || c.dstr_type? } &&
+            dstr_node.children.all? { |c| c.type?(:str, :dstr) } &&
             dstr_node.children.none?(&:multiline?)
         end
 
@@ -127,7 +127,7 @@ module RuboCop
 
         def base_column(child)
           grandparent = child.parent.parent
-          if grandparent&.type == :pair
+          if grandparent&.pair_type?
             grandparent.loc.column
           else
             child.source_range.source_line =~ /\S/

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

@@ -75,6 +75,7 @@ module RuboCop
           check_for_breakable_block(node)
         end
         alias on_numblock on_block
+        alias on_itblock on_block
 
         def on_str(node)
           check_for_breakable_str(node)
@@ -90,7 +91,9 @@ module RuboCop
         alias on_array on_potential_breakable_node
         alias on_hash on_potential_breakable_node
         alias on_send on_potential_breakable_node
+        alias on_csend on_potential_breakable_node
         alias on_def on_potential_breakable_node
+        alias on_defs on_potential_breakable_node
 
         def on_new_investigation
           return unless processed_source.raw_source.include?(';')
@@ -208,7 +211,7 @@ module RuboCop
         # are not bisected.
         # If the string contains spaces, use them to determine a place for a clean break;
         # otherwise, the string will be broken at the line length limit.
-        def breakable_string_range(node) # rubocop:disable Metrics/AbcSize
+        def breakable_string_range(node)
           source_range = node.source_range
           relevant_substr = largest_possible_string(node)
 
@@ -220,13 +223,13 @@ module RuboCop
             adjustment = max - source_range.last_column - 3
             return if adjustment.abs > source_range.size
 
-            source_range.adjust(end_pos: max - source_range.last_column - 3)
+            source_range.adjust(end_pos: adjustment)
           end
         end
 
         def breakable_dstr_begin_position(node)
           source_range = node.source_range
-          source_range.begin_pos if source_range.begin_pos < max && source_range.end_pos >= max
+          source_range.begin_pos if source_range.column < max && source_range.last_column >= max
         end
 
         def breakable_range_by_line_index
@@ -369,7 +372,9 @@ module RuboCop
 
         def string_delimiter(node)
           delimiter = node.loc.begin
-          delimiter ||= node.parent.loc.begin if node.parent&.dstr_type?
+          if node.parent&.dstr_type? && node.parent.loc.respond_to?(:begin)
+            delimiter ||= node.parent.loc.begin
+          end
           delimiter = delimiter&.source
 
           delimiter if %w[' "].include?(delimiter)

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

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

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

@@ -52,7 +52,7 @@ module RuboCop
         def on_hash(node)
           # This cop only deals with hashes wrapped by a set of curly
           # braces like {foo: 1}. That is, not a kwargs hashes.
-          # Style/MultilineMethodArgumentLineBreaks handles those.
+          # Layout/MultilineMethodArgumentLineBreaks handles those.
           return unless starts_with_curly_brace?(node)
           return unless node.loc.begin
 

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

@@ -33,6 +33,18 @@ module RuboCop
       #
       # @example AllowMultilineFinalElement: false (default)
       #
+      #   # bad
+      #   foo(a, b,
+      #     c
+      #   )
+      #
+      #   # bad
+      #   foo(
+      #     a, b, {
+      #       foo: "bar",
+      #     }
+      #   )
+      #
       #   # good
       #   foo(
       #     a,
@@ -44,6 +56,18 @@ module RuboCop
       #
       # @example AllowMultilineFinalElement: true
       #
+      #   # bad
+      #   foo(a, b,
+      #     c
+      #   )
+      #
+      #   # good
+      #   foo(
+      #     a, b, {
+      #       foo: "bar",
+      #     }
+      #   )
+      #
       #   # good
       #   foo(
       #     a,
@@ -75,6 +99,7 @@ module RuboCop
 
           check_line_breaks(node, args, ignore_last: ignore_last_element?)
         end
+        alias on_csend on_send
 
         private
 

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

@@ -109,6 +109,7 @@ module RuboCop
         def on_send(node)
           check_brace_layout(node)
         end
+        alias on_csend on_send
 
         private
 

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

@@ -100,7 +100,7 @@ module RuboCop
 
         def extra_indentation(given_style, parent)
           if given_style == :indented_relative_to_receiver
-            if parent && (parent.splat_type? || parent.kwsplat_type?)
+            if parent&.type?(:splat, :kwsplat)
               configured_indentation_width - parent.loc.operator.length
             else
               configured_indentation_width
@@ -216,7 +216,7 @@ module RuboCop
 
         def get_dot_right_above(node)
           node.each_ancestor.find do |a|
-            dot = a.loc.respond_to?(:dot) && a.loc.dot
+            dot = a.loc.dot if a.loc?(:dot)
             next unless dot
 
             dot.line == node.loc.dot.line - 1 && dot.column == node.loc.dot.column
@@ -224,7 +224,7 @@ module RuboCop
         end
 
         def find_multiline_block_chain_node(node)
-          return unless (block_node = node.each_descendant(:block, :numblock).first)
+          return unless (block_node = node.each_descendant(:any_block).first)
           return unless block_node.multiline? && block_node.parent.call_type?
 
           if node.receiver.call_type?
@@ -239,7 +239,7 @@ module RuboCop
           node = node.receiver while node.receiver
           # ascend to first call which has a dot
           node = node.parent
-          node = node.parent until node.loc.respond_to?(:dot) && node.loc.dot
+          node = node.parent until node.loc?(:dot)
 
           node
         end

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

@@ -65,6 +65,7 @@ module RuboCop
 
           check_line_breaks(node, node.arguments, ignore_last: ignore_last_element?)
         end
+        alias on_defs on_def
 
         private
 

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

@@ -118,7 +118,7 @@ module RuboCop
         end
 
         def right_hand_side(send_node)
-          send_node.first_argument.source_range
+          send_node.first_argument&.source_range
         end
       end
     end

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

@@ -6,25 +6,29 @@ module RuboCop
       # Checks whether certain expressions, e.g. method calls, that could fit
       # completely on a single line, are broken up into multiple lines unnecessarily.
       #
-      # @example any configuration
+      # @example
       #   # bad
       #   foo(
       #     a,
       #     b
       #   )
       #
+      #   # good
+      #   foo(a, b)
+      #
+      #   # bad
       #   puts 'string that fits on ' \
       #        'a single line'
       #
+      #   # good
+      #   puts 'string that fits on a single line'
+      #
+      #   # bad
       #   things
       #     .select { |thing| thing.cond? }
       #     .join('-')
       #
       #   # good
-      #   foo(a, b)
-      #
-      #   puts 'string that fits on a single line'
-      #
       #   things.select { |thing| thing.cond? }.join('-')
       #
       # @example InspectBlocks: false (default)
@@ -103,24 +107,25 @@ module RuboCop
 
         def configured_to_not_be_inspected?(node)
           return true if other_cop_takes_precedence?(node)
+          return false if cop_config['InspectBlocks']
 
-          !cop_config['InspectBlocks'] && (node.block_type? ||
-                                           any_descendant?(node, :block, &:multiline?))
+          node.any_block_type? || any_descendant?(node, :any_block, &:multiline?)
         end
 
         def other_cop_takes_precedence?(node)
-          single_line_block_chain_enabled? && any_descendant?(node, :block) do |block_node|
+          single_line_block_chain_enabled? && any_descendant?(node, :any_block) do |block_node|
             block_node.parent.send_type? && block_node.parent.loc.dot && !block_node.multiline?
           end
         end
 
         def single_line_block_chain_enabled?
-          @config.for_cop('Layout/SingleLineBlockChain')['Enabled']
+          @config.cop_enabled?('Layout/SingleLineBlockChain')
         end
 
         def convertible_block?(node)
-          parent = node.parent
-          parent&.block_type? && node == parent.send_node &&
+          return false unless (parent = node.parent)
+
+          parent.any_block_type? && node == parent.send_node &&
             (node.parenthesized? || !node.arguments?)
         end
       end

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

@@ -29,8 +29,7 @@ module RuboCop
         MSG = '`%<kw_loc>s` at %<kw_loc_line>d, %<kw_loc_column>d is not ' \
               'aligned with `%<beginning>s` at ' \
               '%<begin_loc_line>d, %<begin_loc_column>d.'
-        ANCESTOR_TYPES = %i[kwbegin def defs class module block numblock].freeze
-        ANCESTOR_TYPES_WITH_ACCESS_MODIFIERS = %i[def defs].freeze
+        ANCESTOR_TYPES = %i[kwbegin any_def class module any_block].freeze
         ALTERNATIVE_ACCESS_MODIFIERS = %i[public_class_method private_class_method].freeze
 
         def on_resbody(node)
@@ -96,7 +95,7 @@ module RuboCop
         def alignment_source(node, starting_loc)
           ending_loc =
             case node.type
-            when :block, :numblock, :kwbegin
+            when :block, :numblock, :itblock, :kwbegin
               node.loc.begin
             when :def, :defs, :class, :module,
                  :lvasgn, :ivasgn, :cvasgn, :gvasgn, :casgn
@@ -162,8 +161,7 @@ module RuboCop
         end
 
         def access_modifier_node(node)
-          return nil unless
-            ANCESTOR_TYPES_WITH_ACCESS_MODIFIERS.include?(node.type)
+          return nil unless node.any_def_type?
 
           access_modifier_node = node.ancestors.first
           return nil unless access_modifier?(access_modifier_node)

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

@@ -39,7 +39,7 @@ module RuboCop
 
         def offending_range(node)
           receiver = node.receiver
-          return unless receiver&.block_type?
+          return unless receiver&.any_block_type?
 
           receiver_location = receiver.loc
           closing_block_delimiter_line_num = receiver_location.end.line

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

@@ -3,9 +3,9 @@
 module RuboCop
   module Cop
     module Layout
-      # Checks for colon (:) not followed by some kind of space.
+      # Checks for colon (`:`) not followed by some kind of space.
       # N.B. this cop does not handle spaces after a ternary operator, which are
-      # instead handled by Layout/SpaceAroundOperators.
+      # instead handled by `Layout/SpaceAroundOperators`.
       #
       # @example
       #   # bad

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # Checks for comma (,) not followed by some kind of space.
+      # Checks for comma (`,`) not followed by some kind of space.
       #
       # @example
       #

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

@@ -22,7 +22,7 @@ module RuboCop
 
         def on_def(node)
           args = node.arguments
-          return unless args.loc.begin&.is?('(')
+          return unless args.parenthesized_call?
 
           expr = args.source_range
           pos_before_left_paren = range_between(expr.begin_pos - 1, expr.begin_pos)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # Checks for semicolon (;) not followed by some kind of space.
+      # Checks for semicolon (`;`) not followed by some kind of space.
       #
       # @example
       #   # bad

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

@@ -36,6 +36,7 @@ module RuboCop
         ACCEPT_LEFT_PAREN = %w[break defined? next not rescue return super yield].freeze
         ACCEPT_LEFT_SQUARE_BRACKET = %w[super yield].freeze
         ACCEPT_NAMESPACE_OPERATOR = 'super'
+        RESTRICT_ON_SEND = %i[!].freeze
 
         def on_and(node)
           check(node, [:operator].freeze) if node.keyword?

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

@@ -51,7 +51,7 @@ module RuboCop
         alias on_csend on_send
 
         def on_const(node)
-          return unless node.loc.respond_to?(:double_colon) && node.loc.double_colon
+          return unless node.loc?(:double_colon)
 
           check_space_after_double_colon(node)
         end

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

@@ -242,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)
@@ -260,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_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_block_braces.rb

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

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,119 @@
+# 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)
+          final_node = begin_node.children.last
+
+          return unless begin_node.parent.regexp_type?
+          return unless final_node.array_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

@@ -14,7 +14,7 @@ module RuboCop
       # Although these can be rewritten in a different way, it should not be necessary to
       # 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.
+      # are covered by `Lint/NumericOperationWithConstantResult` instead.
       #
       # @safety
       #   This cop is unsafe as it does not consider side effects when calling methods

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