rubocop 1.70.0 → 1.71.2

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_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/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/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

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

@@ -96,22 +96,18 @@ module RuboCop
         private
 
         def fixed_constant_path?(node)
-          node.each_path.all? { |path| path.cbase_type? || path.const_type? || path.self_type? }
+          node.each_path.all? { |path| path.type?(:cbase, :const, :self) }
         end
 
         def simple_assignment?(node)
           node.ancestors.all? do |ancestor|
-            return true if namespace_definition?(ancestor)
+            return true if ancestor.type?(:module, :class)
 
             ancestor.begin_type? || ancestor.literal? || ancestor.casgn_type? ||
               freeze_method?(ancestor)
           end
         end
 
-        def namespace_definition?(node)
-          node.module_type? || node.class_type?
-        end
-
         def freeze_method?(node)
           node.send_type? && node.method?(:freeze)
         end

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

@@ -116,7 +116,7 @@ module RuboCop
 
         def assumed_usage_context?(node)
           # Basically, debugger methods are not used as a method argument without arguments.
-          return false unless node.arguments.empty? && node.each_ancestor(:send, :csend).any?
+          return false unless node.arguments.empty? && node.each_ancestor(:call).any?
           return true if assumed_argument?(node)
 
           node.each_ancestor.none? do |ancestor|

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

@@ -106,7 +106,7 @@ module RuboCop
         private
 
         def pattern_identity(pattern)
-          pattern_source = if pattern.hash_pattern_type? || pattern.match_alt_type?
+          pattern_source = if pattern.type?(:hash_pattern, :match_alt)
                              pattern.children.map(&:source).sort.to_s
                            else
                              pattern.source

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for duplicate elements in Regexp character classes.
+      # Checks for duplicate elements in `Regexp` character classes.
       #
       # @example
       #

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for duplicate literal, constant, or variable elements in Set and SortedSet.
+      # Checks for duplicate literal, constant, or variable elements in `Set` and `SortedSet`.
       #
       # @example
       #

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

@@ -14,8 +14,6 @@ module RuboCop
       #     bar
       #   end
       #
-      # @example
-      #
       #   # good
       #
       #   foo = (some_expression)

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

@@ -36,7 +36,8 @@ module RuboCop
       #   # https://www.embeddeduse.com/2019/08/26/qt-compare-two-floats/
       #
       class FloatComparison < Base
-        MSG = 'Avoid (in)equality comparisons of floats as they are unreliable.'
+        MSG_EQUALITY = 'Avoid equality comparisons of floats as they are unreliable.'
+        MSG_INEQUALITY = 'Avoid inequality comparisons of floats as they are unreliable.'
 
         EQUALITY_METHODS = %i[== != eql? equal?].freeze
         FLOAT_RETURNING_METHODS = %i[to_f Float fdiv].freeze
@@ -52,8 +53,10 @@ module RuboCop
 
           return if literal_safe?(lhs) || literal_safe?(rhs)
 
-          add_offense(node) if float?(lhs) || float?(rhs)
+          message = node.method?(:!=) ? MSG_INEQUALITY : MSG_EQUALITY
+          add_offense(node, message: message) if float?(lhs) || float?(rhs)
         end
+        alias on_csend on_send
 
         private
 

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Identifies Float literals which are, like, really really really
+      # Identifies `Float` literals which are, like, really really really
       # really really really really really big. Too big. No-one needs Floats
       # that big. If you need a float that big, something is wrong with you.
       #

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

@@ -73,7 +73,7 @@ module RuboCop
 
           first_arg = node.first_argument
           return false if num_of_expected_fields.zero? &&
-                          (first_arg.dstr_type? || first_arg.array_type?)
+                          first_arg.type?(:dstr, :array)
 
           matched_arguments_count?(num_of_expected_fields, num_of_format_args)
         end

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

@@ -82,7 +82,7 @@ module RuboCop
         end
 
         def string_literal?(node)
-          node.str_type? || node.dstr_type?
+          node.type?(:str, :dstr)
         end
 
         def string_literals?(node1, node2)

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

@@ -5,6 +5,9 @@ module RuboCop
     module Lint
       # Checks for interpolated literals.
       #
+      # NOTE: Array literals interpolated in regexps are not handled by this cop, but
+      # by `Lint/ArrayLiteralInRegexp` instead.
+      #
       # @example
       #
       #   # bad
@@ -55,8 +58,10 @@ module RuboCop
           node &&
             !special_keyword?(node) &&
             prints_as_self?(node) &&
-            # Special case for Layout/TrailingWhitespace
-            !(space_literal?(node) && ends_heredoc_line?(node))
+            # Special case for `Layout/TrailingWhitespace`
+            !(space_literal?(node) && ends_heredoc_line?(node)) &&
+            # Handled by `Lint/ArrayLiteralInRegexp`
+            !array_in_regexp?(node)
         end
 
         def special_keyword?(node)
@@ -64,6 +69,11 @@ module RuboCop
           (node.str_type? && !node.loc.respond_to?(:begin)) || node.source_range.is?('__LINE__')
         end
 
+        def array_in_regexp?(node)
+          grandparent = node.parent.parent
+          node.array_type? && grandparent.regexp_type?
+        end
+
         # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
         def autocorrected_value(node)
           case node.type
@@ -189,7 +199,7 @@ module RuboCop
 
         def in_array_percent_literal?(node)
           parent = node.parent
-          return false unless parent.dstr_type? || parent.dsym_type?
+          return false unless parent.type?(:dstr, :dsym)
 
           grandparent = parent.parent
           grandparent&.array_type? && grandparent.percent_literal?

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

@@ -97,7 +97,7 @@ module RuboCop
 
         # @!method class_new_block(node)
         def_node_matcher :class_new_block, <<~RUBY
-          ({block numblock}
+          (any_block
             (send
               (const {nil? cbase} :Class) :new $_) ...)
         RUBY
@@ -135,7 +135,7 @@ module RuboCop
         end
 
         def inside_class_with_stateful_parent?(node)
-          if (block_node = node.each_ancestor(:block, :numblock).first)
+          if (block_node = node.each_ancestor(:any_block).first)
             return false unless (super_class = class_new_block(block_node))
 
             !allowed_class?(super_class)

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

@@ -8,7 +8,7 @@ module RuboCop
       # Offenses are registered for regexp character classes like `/[A-z]/`
       # as well as range objects like `('A'..'z')`.
       #
-      # NOTE: Range objects cannot be autocorrected.
+      # NOTE: `Range` objects cannot be autocorrected.
       #
       # @safety
       #   The cop autocorrects regexp character classes

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Do not mix named captures and numbered captures in a Regexp literal
+      # Do not mix named captures and numbered captures in a `Regexp` literal
       # because numbered capture is ignored if they're mixed.
       # Replace numbered captures with non-capturing groupings or
       # named captures.

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

@@ -102,7 +102,7 @@ module RuboCop
           return unless def_ancestor
 
           within_scoping_def =
-            node.each_ancestor(:block, :numblock, :sclass).any? do |ancestor|
+            node.each_ancestor(:any_block, :sclass).any? do |ancestor|
               scoping_method_call?(ancestor)
             end
 
@@ -129,12 +129,12 @@ module RuboCop
 
         # @!method eval_call?(node)
         def_node_matcher :eval_call?, <<~PATTERN
-          ({block numblock} (send _ {:instance_eval :class_eval :module_eval} ...) ...)
+          (any_block (send _ {:instance_eval :class_eval :module_eval} ...) ...)
         PATTERN
 
         # @!method exec_call?(node)
         def_node_matcher :exec_call?, <<~PATTERN
-          ({block numblock} (send _ {:instance_exec :class_exec :module_exec} ...) ...)
+          (any_block (send _ {:instance_exec :class_exec :module_exec} ...) ...)
         PATTERN
       end
     end

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

@@ -43,7 +43,7 @@ module RuboCop
         PATTERN
 
         def parent_block_node(node)
-          node.each_ancestor(:block, :numblock).first
+          node.each_ancestor(:any_block).first
         end
       end
     end

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

@@ -66,7 +66,7 @@ module RuboCop
         private
 
         def scoped_node?(node)
-          node.def_type? || node.defs_type? || node.lambda?
+          node.type?(:def, :defs) || node.lambda?
         end
 
         def return_value?(return_node)

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

@@ -9,10 +9,10 @@ module RuboCop
       # As such, they can be replaced with that result.
       # These are probably leftover from debugging, or are mistakes.
       # Other numeric operations that are similarly leftover from debugging or mistakes
-      # are handled by Lint/UselessNumericOperation.
+      # are handled by `Lint/UselessNumericOperation`.
       #
       # NOTE: This cop doesn't detect offenses for the `-` and `%` operator because it
-      # can't determine the type of `x`. If `x` is an Array or String, it doesn't perform
+      # can't determine the type of `x`. If `x` is an `Array` or `String`, it doesn't perform
       # a numeric operation.
       #
       # @example
@@ -50,43 +50,38 @@ module RuboCop
 
         # @!method operation_with_constant_result?(node)
         def_node_matcher :operation_with_constant_result?,
-                         '(send (send nil? $_) $_ ({int | send nil?} $_))'
+                         '(call (call nil? $_lhs) $_operation ({int | call nil?} $_rhs))'
 
         # @!method abbreviated_assignment_with_constant_result?(node)
         def_node_matcher :abbreviated_assignment_with_constant_result?,
-                         '(op-asgn (lvasgn $_) $_ ({int | lvar} $_))'
+                         '(op-asgn (lvasgn $_lhs) $_operation ({int lvar} $_rhs))'
 
         def on_send(node)
-          return unless operation_with_constant_result?(node)
-
-          variable, operation, number = operation_with_constant_result?(node)
-          result = constant_result?(variable, operation, number)
-          return unless result
+          return unless (lhs, operation, rhs = operation_with_constant_result?(node))
+          return unless (result = constant_result?(lhs, operation, rhs))
 
           add_offense(node) do |corrector|
             corrector.replace(node, result.to_s)
           end
         end
+        alias on_csend on_send
 
         def on_op_asgn(node)
-          return unless abbreviated_assignment_with_constant_result?(node)
-
-          variable, operation, number = abbreviated_assignment_with_constant_result?(node)
-          result = constant_result?(variable, operation, number)
-          return unless result
+          return unless (lhs, operation, rhs = abbreviated_assignment_with_constant_result?(node))
+          return unless (result = constant_result?(lhs, operation, rhs))
 
           add_offense(node) do |corrector|
-            corrector.replace(node, "#{variable} = #{result}")
+            corrector.replace(node, "#{lhs} = #{result}")
           end
         end
 
         private
 
-        def constant_result?(variable, operation, number)
-          if number.to_s == '0'
+        def constant_result?(lhs, operation, rhs)
+          if rhs.to_s == '0'
             return 0 if operation == :*
             return 1 if operation == :**
-          elsif number == variable
+          elsif rhs == lhs
             return 1 if operation == :/
           end
           # If we weren't able to find any matches, return false so we can bail out.

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Looks for references of Regexp captures that are out of range
+      # Looks for references of `Regexp` captures that are out of range
       # and thus always returns nil.
       #
       # @safety
@@ -61,6 +61,7 @@ module RuboCop
             check_regexp(node.receiver)
           end
         end
+        alias after_csend after_send
 
         def on_when(node)
           regexp_conditions = node.conditions.select(&:regexp_type?)

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

@@ -38,16 +38,12 @@ module RuboCop
 
         def valid_context?(node)
           return true unless node.arguments.one? && node.first_argument.parenthesized_call?
-          return true if first_argument_block_type?(node.first_argument)
+          return true if node.first_argument.any_block_type?
 
           node.operator_method? || node.setter_method? || chained_calls?(node) ||
             valid_first_argument?(node.first_argument)
         end
 
-        def first_argument_block_type?(first_arg)
-          first_arg.block_type? || first_arg.numblock_type?
-        end
-
         def valid_first_argument?(first_arg)
           first_arg.operator_keyword? || first_arg.hash_type? || ternary_expression?(first_arg) ||
             compound_range?(first_arg)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for redundant quantifiers inside Regexp literals.
+      # Checks for redundant quantifiers inside `Regexp` literals.
       #
       # It is always allowed when interpolation is used in a regexp literal,
       # because it's unknown what kind of string will be expanded as a result:

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

@@ -29,7 +29,7 @@ module RuboCop
         RESTRICT_ON_SEND = %i[print puts warn].freeze
 
         # @!method to_s_without_args?(node)
-        def_node_matcher :to_s_without_args?, '(send _ :to_s)'
+        def_node_matcher :to_s_without_args?, '(call _ :to_s)'
 
         def on_interpolation(begin_node)
           final_node = begin_node.children.last
@@ -42,7 +42,7 @@ module RuboCop
         def on_send(node)
           return if node.receiver
 
-          node.each_child_node(:send) do |child|
+          node.each_child_node(:call) do |child|
             next if !child.method?(:to_s) || child.arguments.any?
 
             register_offense(child, "`#{node.method_name}`")

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for `rescue` blocks targeting the Exception class.
+      # Checks for `rescue` blocks targeting the `Exception` class.
       #
       # @example
       #

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

@@ -33,7 +33,7 @@ module RuboCop
         def_node_matcher :bad_method?, <<~PATTERN
           {
             (send $(csend ...) $_ ...)
-            (send $({block numblock} (csend ...) ...) $_ ...)
+            (send $(any_block (csend ...) ...) $_ ...)
           }
         PATTERN
 
@@ -97,12 +97,19 @@ module RuboCop
         end
 
         def require_parentheses?(send_node)
+          return true if operator_inside_hash?(send_node)
           return false unless send_node.comparison_method?
           return false unless (node = send_node.parent)
 
           (node.respond_to?(:logical_operator?) && node.logical_operator?) ||
             (node.respond_to?(:comparison_method?) && node.comparison_method?)
         end
+
+        def operator_inside_hash?(send_node)
+          # If an operator call (without a dot) is inside a hash, it needs
+          # to be parenthesized when converted to safe navigation.
+          send_node.parent&.pair_type? && !send_node.loc.dot
+        end
       end
     end
   end