rubocop 1.69.2 → 1.72.2

data/lib/rubocop/cop/mixin/hash_subset.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for Style/HashExcept and Style/HashSlice cops.
+    # It registers an offense on methods with blocks that are equivalent
+    # to Hash#except or Hash#slice.
+    # rubocop:disable Metrics/ModuleLength
+    module HashSubset
+      include RangeHelp
+      extend NodePattern::Macros
+
+      RESTRICT_ON_SEND = %i[reject select filter].freeze
+
+      SUBSET_METHODS = %i[== != eql? include?].freeze
+      ACTIVE_SUPPORT_SUBSET_METHODS = (SUBSET_METHODS + %i[in? exclude?]).freeze
+
+      MSG = 'Use `%<prefer>s` instead.'
+
+      # @!method block_with_first_arg_check?(node)
+      def_node_matcher :block_with_first_arg_check?, <<~PATTERN
+        (block
+          (call _ _)
+          (args
+            $(arg _key)
+            (arg _))
+          {
+            $(send
+              {(lvar _key) $_ _ | _ $_ (lvar _key)})
+            (send
+              $(send
+                {(lvar _key) $_ _ | _ $_ (lvar _key)}) :!)
+            })
+      PATTERN
+
+      def on_send(node)
+        offense_range, key_source = extract_offense(node)
+
+        return unless offense_range
+        return unless semantically_subset_method?(node)
+
+        preferred_method = "#{preferred_method_name}(#{key_source})"
+        add_offense(offense_range, message: format(MSG, prefer: preferred_method)) do |corrector|
+          corrector.replace(offense_range, preferred_method)
+        end
+      end
+      alias on_csend on_send
+
+      private
+
+      def semantically_subset_method?(node)
+        raise NotImplementedError
+      end
+
+      def preferred_method_name
+        raise NotImplementedError
+      end
+
+      def extract_offense(node)
+        block = node.parent
+        return unless extracts_hash_subset?(block)
+
+        except_key = except_key(block)
+        return if except_key.nil? || !safe_to_register_offense?(block, except_key)
+
+        [offense_range(node), except_key_source(except_key)]
+      end
+
+      def extracts_hash_subset?(block)
+        block_with_first_arg_check?(block) do |key_arg, send_node, method|
+          # Only consider methods that have one argument
+          return false unless send_node.arguments.one?
+
+          return false unless supported_subset_method?(method)
+          return false if range_include?(send_node)
+
+          case method
+          when :include?, :exclude?
+            send_node.first_argument.source == key_arg.source
+          when :in?
+            send_node.receiver.source == key_arg.source
+          else
+            true
+          end
+        end
+      end
+
+      def range_include?(send_node)
+        # When checking `include?`, `exclude?` and `in?` for offenses, if the receiver
+        # or first argument is a range, an offense should not be registered.
+        # ie. `(1..5).include?(k)` or `k.in?('a'..'z')`
+
+        return true if send_node.first_argument.range_type?
+
+        receiver = send_node.receiver
+        receiver = receiver.child_nodes.first while receiver.begin_type?
+        receiver.range_type?
+      end
+
+      def supported_subset_method?(method)
+        if active_support_extensions_enabled?
+          ACTIVE_SUPPORT_SUBSET_METHODS.include?(method)
+        else
+          SUBSET_METHODS.include?(method)
+        end
+      end
+
+      def semantically_except_method?(node)
+        block = node.parent
+        body, negated = extract_body_if_negated(block.body)
+
+        if node.method?('reject')
+          body.method?('==') || body.method?('eql?') || included?(body, negated)
+        else
+          body.method?('!=') || not_included?(body, negated)
+        end
+      end
+
+      def semantically_slice_method?(node)
+        !semantically_except_method?(node)
+      end
+
+      def included?(body, negated)
+        if negated
+          body.method?('exclude?')
+        else
+          body.method?('include?') || body.method?('in?')
+        end
+      end
+
+      def not_included?(body, negated)
+        included?(body, !negated)
+      end
+
+      def safe_to_register_offense?(block, except_key)
+        body = block.body
+
+        if body.method?('==') || body.method?('!=')
+          except_key.type?(:sym, :str)
+        else
+          true
+        end
+      end
+
+      def extract_body_if_negated(body)
+        if body.method?('!')
+          [body.receiver, true]
+        else
+          [body, false]
+        end
+      end
+
+      def except_key_source(key)
+        if key.array_type?
+          key = if key.percent_literal?
+                  key.each_value.map { |v| decorate_source(v) }
+                else
+                  key.each_value.map(&:source)
+                end
+          return key.join(', ')
+        end
+
+        key.literal? ? key.source : "*#{key.source}"
+      end
+
+      def decorate_source(value)
+        return ":\"#{value.source}\"" if value.dsym_type?
+        return "\"#{value.source}\"" if value.dstr_type?
+        return ":#{value.source}" if value.sym_type?
+
+        "'#{value.source}'"
+      end
+
+      def except_key(node)
+        key_arg = node.argument_list.first.source
+        body, = extract_body_if_negated(node.body)
+        lhs, _method_name, rhs = *body
+
+        lhs.source == key_arg ? rhs : lhs
+      end
+
+      def offense_range(node)
+        range_between(node.loc.selector.begin_pos, node.parent.loc.end.end_pos)
+      end
+    end
+    # rubocop:enable Metrics/ModuleLength
+  end
+end

data/lib/rubocop/cop/mixin/hash_transform_method.rb

@@ -9,6 +9,80 @@ module RuboCop
 
       RESTRICT_ON_SEND = %i[[] to_h].freeze
 
+      # Internal helper class to hold match data
+      Captures = Struct.new(:transformed_argname, :transforming_body_expr, :unchanged_body_expr) do
+        def noop_transformation?
+          transforming_body_expr.lvar_type? &&
+            transforming_body_expr.children == [transformed_argname]
+        end
+
+        def transformation_uses_both_args?
+          transforming_body_expr.descendants.include?(unchanged_body_expr)
+        end
+
+        def use_transformed_argname?
+          transforming_body_expr.each_descendant(:lvar).any? do |node|
+            node.source == transformed_argname.to_s
+          end
+        end
+      end
+
+      # Internal helper class to hold autocorrect data
+      Autocorrection = Struct.new(:match, :block_node, :leading, :trailing) do
+        def self.from_each_with_object(node, match)
+          new(match, node, 0, 0)
+        end
+
+        def self.from_hash_brackets_map(node, match)
+          new(match, node.children.last, 'Hash['.length, ']'.length)
+        end
+
+        def self.from_map_to_h(node, match)
+          if node.parent&.block_type? && node.parent.send_node == node
+            strip_trailing_chars = 0
+          else
+            map_range = node.children.first.source_range
+            node_range = node.source_range
+            strip_trailing_chars = node_range.end_pos - map_range.end_pos
+          end
+
+          new(match, node.children.first, 0, strip_trailing_chars)
+        end
+
+        def self.from_to_h(node, match)
+          new(match, node, 0, 0)
+        end
+
+        def strip_prefix_and_suffix(node, corrector)
+          expression = node.source_range
+          corrector.remove_leading(expression, leading)
+          corrector.remove_trailing(expression, trailing)
+        end
+
+        def set_new_method_name(new_method_name, corrector)
+          range = block_node.send_node.loc.selector
+          if (send_end = block_node.send_node.loc.end)
+            # If there are arguments (only true in the `each_with_object`
+            # case)
+            range = range.begin.join(send_end)
+          end
+          corrector.replace(range, new_method_name)
+        end
+
+        def set_new_arg_name(transformed_argname, corrector)
+          corrector.replace(block_node.arguments, "|#{transformed_argname}|")
+        end
+
+        def set_new_body_expression(transforming_body_expr, corrector)
+          body_source = transforming_body_expr.source
+          if transforming_body_expr.hash_type? && !transforming_body_expr.braces?
+            body_source = "{ #{body_source} }"
+          end
+
+          corrector.replace(block_node.body, body_source)
+        end
+      end
+
       # @!method array_receiver?(node)
       def_node_matcher :array_receiver?, <<~PATTERN
         {(array ...) (send _ :each_with_index) (send _ :with_index _ ?) (send _ :zip ...)}
@@ -113,80 +187,6 @@ module RuboCop
         correction.set_new_arg_name(captures.transformed_argname, corrector)
         correction.set_new_body_expression(captures.transforming_body_expr, corrector)
       end
-
-      # Internal helper class to hold match data
-      Captures = Struct.new(:transformed_argname, :transforming_body_expr, :unchanged_body_expr) do
-        def noop_transformation?
-          transforming_body_expr.lvar_type? &&
-            transforming_body_expr.children == [transformed_argname]
-        end
-
-        def transformation_uses_both_args?
-          transforming_body_expr.descendants.include?(unchanged_body_expr)
-        end
-
-        def use_transformed_argname?
-          transforming_body_expr.each_descendant(:lvar).any? do |node|
-            node.source == transformed_argname.to_s
-          end
-        end
-      end
-
-      # Internal helper class to hold autocorrect data
-      Autocorrection = Struct.new(:match, :block_node, :leading, :trailing) do
-        def self.from_each_with_object(node, match)
-          new(match, node, 0, 0)
-        end
-
-        def self.from_hash_brackets_map(node, match)
-          new(match, node.children.last, 'Hash['.length, ']'.length)
-        end
-
-        def self.from_map_to_h(node, match)
-          if node.parent&.block_type? && node.parent.send_node == node
-            strip_trailing_chars = 0
-          else
-            map_range = node.children.first.source_range
-            node_range = node.source_range
-            strip_trailing_chars = node_range.end_pos - map_range.end_pos
-          end
-
-          new(match, node.children.first, 0, strip_trailing_chars)
-        end
-
-        def self.from_to_h(node, match)
-          new(match, node, 0, 0)
-        end
-
-        def strip_prefix_and_suffix(node, corrector)
-          expression = node.source_range
-          corrector.remove_leading(expression, leading)
-          corrector.remove_trailing(expression, trailing)
-        end
-
-        def set_new_method_name(new_method_name, corrector)
-          range = block_node.send_node.loc.selector
-          if (send_end = block_node.send_node.loc.end)
-            # If there are arguments (only true in the `each_with_object`
-            # case)
-            range = range.begin.join(send_end)
-          end
-          corrector.replace(range, new_method_name)
-        end
-
-        def set_new_arg_name(transformed_argname, corrector)
-          corrector.replace(block_node.arguments, "|#{transformed_argname}|")
-        end
-
-        def set_new_body_expression(transforming_body_expr, corrector)
-          body_source = transforming_body_expr.source
-          if transforming_body_expr.hash_type? && !transforming_body_expr.braces?
-            body_source = "{ #{body_source} }"
-          end
-
-          corrector.replace(block_node.body, body_source)
-        end
-      end
     end
   end
 end

data/lib/rubocop/cop/mixin/method_complexity.rb

@@ -35,7 +35,7 @@ module RuboCop
 
       # @!method define_method?(node)
       def_node_matcher :define_method?, <<~PATTERN
-        ({block numblock}
+        (any_block
          (send nil? :define_method ({sym str} $_)) _ _)
       PATTERN
 

data/lib/rubocop/cop/mixin/percent_literal.rb

@@ -21,7 +21,7 @@ module RuboCop
       end
 
       def begin_source(node)
-        node.loc.begin.source if node.loc.respond_to?(:begin) && node.loc.begin
+        node.loc.begin.source if node.loc?(:begin)
       end
 
       def type(node)

data/lib/rubocop/cop/mixin/preceding_following_alignment.rb

@@ -4,7 +4,12 @@ module RuboCop
   module Cop
     # Common functionality for checking whether an AST node/token is aligned
     # with something on a preceding or following line
+    # rubocop:disable Metrics/ModuleLength
     module PrecedingFollowingAlignment
+      # Tokens that end with an `=`, as well as `<<`, that can be aligned together:
+      # `=`, `==`, `===`, `!=`, `<=`, `>=`, `<<` and operator assignment (`+=`, etc).
+      ASSIGNMENT_OR_COMPARISON_TOKENS = %i[tEQL tEQ tEQQ tNEQ tLEQ tGEQ tOP_ASGN tLSHFT].freeze
+
       private
 
       def allow_for_alignment?
@@ -19,16 +24,20 @@ module RuboCop
         aligned_with_adjacent_line?(range, method(:aligned_operator?))
       end
 
-      def aligned_with_preceding_assignment(token)
+      # Allows alignment with a preceding operator that ends with an `=`,
+      # including assignment and comparison operators.
+      def aligned_with_preceding_equals_operator(token)
         preceding_line_range = token.line.downto(1)
 
-        aligned_with_assignment(token, preceding_line_range)
+        aligned_with_equals_sign(token, preceding_line_range)
       end
 
-      def aligned_with_subsequent_assignment(token)
+      # Allows alignment with a subsequent operator that ends with an `=`,
+      # including assignment and comparison operators.
+      def aligned_with_subsequent_equals_operator(token)
         subsequent_line_range = token.line.upto(processed_source.lines.length)
 
-        aligned_with_assignment(token, subsequent_line_range)
+        aligned_with_equals_sign(token, subsequent_line_range)
       end
 
       def aligned_with_adjacent_line?(range, predicate)
@@ -75,11 +84,11 @@ module RuboCop
       end
 
       def aligned_token?(range, line, lineno)
-        aligned_words?(range, line) || aligned_assignment?(range, lineno)
+        aligned_words?(range, line) || aligned_equals_operator?(range, lineno)
       end
 
       def aligned_operator?(range, line, lineno)
-        aligned_identical?(range, line) || aligned_assignment?(range, lineno)
+        aligned_identical?(range, line) || aligned_equals_operator?(range, lineno)
       end
 
       def aligned_words?(range, line)
@@ -90,22 +99,24 @@ module RuboCop
         token == line[left_edge, token.length]
       end
 
-      def aligned_assignment?(range, lineno)
-        # Check that assignment is aligned with a previous assignment operator
-        # ie. an equals sign, an operator assignment, or an append operator (`<<`)
+      def aligned_equals_operator?(range, lineno)
+        # Check that the operator is aligned with a previous assignment or comparison operator
+        # ie. an equals sign, an operator assignment (eg. `+=`), a comparison (`==`, `<=`, etc.).
+        # Since append operators (`<<`) are a type of assignment, they are allowed as well,
+        # despite not ending with a literal equals character.
         line_range = processed_source.buffer.line_range(lineno)
         return false unless line_range
 
         # Find the specific token to avoid matching up to operators inside strings
-        assignment_token = processed_source.tokens_within(line_range).detect do |token|
-          token.equal_sign? || token.type == :tLSHFT
+        operator_token = processed_source.tokens_within(line_range).detect do |token|
+          ASSIGNMENT_OR_COMPARISON_TOKENS.include?(token.type)
         end
 
-        aligned_with_preceding_assignment?(range, assignment_token) ||
-          aligned_with_append_operator?(range, assignment_token)
+        aligned_with_preceding_equals?(range, operator_token) ||
+          aligned_with_append_operator?(range, operator_token)
       end
 
-      def aligned_with_preceding_assignment?(range, token)
+      def aligned_with_preceding_equals?(range, token)
         return false unless token
 
         range.source[-1] == '=' && range.last_column == token.pos.last_column
@@ -123,7 +134,7 @@ module RuboCop
         range.source == line[range.column, range.size]
       end
 
-      def aligned_with_assignment(token, line_range)
+      def aligned_with_equals_sign(token, line_range)
         token_line_indent    = processed_source.line_indentation(token.line)
         assignment_lines     = relevant_assignment_lines(line_range)
         relevant_line_number = assignment_lines[1]
@@ -135,7 +146,7 @@ module RuboCop
         return :none if relevant_indent < token_line_indent
         return :none unless processed_source.lines[relevant_line_number - 1]
 
-        aligned_assignment?(token.pos, relevant_line_number) ? :yes : :no
+        aligned_equals_operator?(token.pos, relevant_line_number) ? :yes : :no
       end
 
       def assignment_lines
@@ -146,10 +157,14 @@ module RuboCop
         @assignment_tokens ||= begin
           tokens = processed_source.tokens.select(&:equal_sign?)
 
-          # we don't want to operate on equals signs which are part of an
-          #   optarg in a method definition
-          # e.g.: def method(optarg = default_val); end
-          tokens = remove_optarg_equals(tokens, processed_source)
+          # We don't want to operate on equals signs which are part of an `optarg` in a
+          # method definition, or the separator of an endless method definition.
+          # For example (the equals sign to ignore is highlighted with ^):
+          #     def method(optarg = default_val); end
+          #                       ^
+          #     def method = foo
+          #                ^
+          tokens = remove_equals_in_def(tokens, processed_source)
 
           # Only attempt to align the first = on each line
           Set.new(tokens.uniq(&:line))
@@ -185,11 +200,20 @@ module RuboCop
       # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
       # rubocop:enable Metrics/PerceivedComplexity, Metrics/MethodLength
 
-      def remove_optarg_equals(asgn_tokens, processed_source)
-        optargs    = processed_source.ast.each_node(:optarg)
-        optarg_eql = optargs.to_set { |o| o.loc.operator.begin_pos }
-        asgn_tokens.reject { |t| optarg_eql.include?(t.begin_pos) }
+      def remove_equals_in_def(asgn_tokens, processed_source)
+        nodes = processed_source.ast.each_node(:optarg, :def)
+        eqls_to_ignore = nodes.with_object([]) do |node, arr|
+          loc = if node.def_type?
+                  node.loc.assignment if node.endless?
+                else
+                  node.loc.operator
+                end
+          arr << loc.begin_pos if loc
+        end
+
+        asgn_tokens.reject { |t| eqls_to_ignore.include?(t.begin_pos) }
       end
     end
+    # rubocop:enable Metrics/ModuleLength
   end
 end

data/lib/rubocop/cop/mixin/range_help.rb

@@ -4,9 +4,10 @@ module RuboCop
   module Cop
     # Methods that calculate and return Parser::Source::Ranges
     module RangeHelp
-      private
-
       BYTE_ORDER_MARK = 0xfeff # The Unicode codepoint
+      NOT_GIVEN = Module.new
+
+      private
 
       def source_range(source_buffer, line_number, column, length = 1)
         if column.is_a?(Range)
@@ -51,7 +52,6 @@ module RuboCop
         Parser::Source::Range.new(buffer, begin_pos, end_pos)
       end
 
-      NOT_GIVEN = Module.new
       def range_with_surrounding_space(range_positional = NOT_GIVEN, # rubocop:disable Metrics/ParameterLists
                                        range: NOT_GIVEN, side: :both, newlines: true,
                                        whitespace: false, continuations: false,

data/lib/rubocop/cop/mixin/space_before_punctuation.rb

@@ -36,7 +36,7 @@ module RuboCop
       end
 
       def space_required_after?(token)
-        (token.left_curly_brace? || token.type == :tLAMBEG) && space_required_after_lcurly?
+        token.left_curly_brace? && space_required_after_lcurly?
       end
 
       def space_required_after_lcurly?

data/lib/rubocop/cop/mixin/statement_modifier.rb

@@ -55,14 +55,19 @@ module RuboCop
       end
 
       def if_body_source(if_body)
-        if if_body.call_type? &&
-           if_body.last_argument&.hash_type? && if_body.last_argument.pairs.last&.value_omission?
+        if if_body.call_type? && !if_body.method?(:[]=) && omitted_value_in_last_hash_arg?(if_body)
           "#{method_source(if_body)}(#{if_body.arguments.map(&:source).join(', ')})"
         else
           if_body.source
         end
       end
 
+      def omitted_value_in_last_hash_arg?(if_body)
+        return false unless (last_argument = if_body.last_argument)
+
+        last_argument.hash_type? && last_argument.pairs.last&.value_omission?
+      end
+
       def method_source(if_body)
         end_range = if_body.implicit_call? ? if_body.loc.dot.end : if_body.loc.selector
 
@@ -96,7 +101,7 @@ module RuboCop
       end
 
       def max_line_length
-        return unless config.for_cop('Layout/LineLength')['Enabled']
+        return unless config.cop_enabled?('Layout/LineLength')
 
         config.for_cop('Layout/LineLength')['Max']
       end

data/lib/rubocop/cop/mixin/string_help.rb

@@ -10,7 +10,7 @@ module RuboCop
       def on_str(node)
         # Constants like __FILE__ are handled as strings,
         # but don't respond to begin.
-        return unless node.loc.respond_to?(:begin) && node.loc.begin
+        return unless node.loc?(:begin)
         return if part_of_ignored_node?(node)
 
         if offense?(node)
@@ -33,7 +33,7 @@ module RuboCop
         # A :begin node inside a :dstr, :dsym, or :regexp node is an interpolation.
         node.ancestors
             .drop_while { |a| !a.begin_type? }
-            .any? { |a| a.dstr_type? || a.dsym_type? || a.regexp_type? }
+            .any? { |a| a.type?(:dstr, :dsym, :regexp) }
       end
     end
   end

data/lib/rubocop/cop/mixin/string_literals_help.rb

@@ -26,7 +26,7 @@ module RuboCop
       end
 
       def string_literals_config
-        config.for_cop('Style/StringLiterals')
+        config.for_enabled_cop('Style/StringLiterals')
       end
     end
   end

data/lib/rubocop/cop/mixin/trailing_comma.rb

@@ -2,8 +2,8 @@
 
 module RuboCop
   module Cop
-    # Common methods shared by Style/TrailingCommaInArguments and
-    # Style/TrailingCommaInLiteral
+    # Common methods shared by Style/TrailingCommaInArguments,
+    # Style/TrailingCommaInArrayLiteral and Style/TrailingCommaInHashLiteral
     module TrailingComma
       include ConfigurableEnforcedStyle
       include RangeHelp
@@ -181,7 +181,7 @@ module RuboCop
         #       ...
         #     SOURCE
         #   })
-        return heredoc?(node.children.last) if node.pair_type? || node.hash_type?
+        return heredoc?(node.children.last) if node.type?(:pair, :hash)
 
         false
       end

data/lib/rubocop/cop/naming/block_forwarding.rb

@@ -13,6 +13,20 @@ module RuboCop
       # The default variable name is `block`. If the name is already in use, it will not be
       # autocorrected.
       #
+      # [NOTE]
+      # ====
+      # Because of a bug in Ruby 3.3.0, when a block is referenced inside of another block,
+      # no offense will be registered until Ruby 3.4:
+      #
+      # [source,ruby]
+      # ----
+      # def foo(&block)
+      #   # Using an anonymous block would be a syntax error on Ruby 3.3.0
+      #   block_method { bar(&block) }
+      # end
+      # ----
+      # ====
+      #
       # @example EnforcedStyle: anonymous (default)
       #
       #   # bad
@@ -90,21 +104,11 @@ module RuboCop
           last_argument.source == block_pass_node.source
         end
 
-        # Prevents the following syntax error:
-        #
-        # # foo.rb
-        # def foo(&)
-        #   block_method do
-        #     bar(&)
-        #   end
-        # end
-        #
-        # $ ruby -vc foo.rb
-        # ruby 3.3.0 (2023-12-25 revision 5124f9ac75) [x86_64-darwin22]
-        # foo.rb: foo.rb:4: anonymous block parameter is also used within block (SyntaxError)
-        #
+        # Ruby 3.3.0 had a bug where accessing an anonymous block argument inside of a block
+        # was a syntax error in unambiguous cases: https://bugs.ruby-lang.org/issues/20090
+        # We disallow this also for earlier Ruby versions so that code is forwards compatible.
         def invalidates_syntax?(block_pass_node)
-          block_pass_node.each_ancestor(:block, :numblock).any?
+          target_ruby_version <= 3.3 && block_pass_node.each_ancestor(:any_block).any?
         end
 
         def use_kwarg_in_method_definition?(node)
@@ -138,7 +142,7 @@ module RuboCop
         def use_block_argument_as_local_variable?(node, last_argument)
           return false if node.body.nil?
 
-          node.body.each_descendant(:lvar, :lvasgn).any? do |lvar|
+          node.body.each_node(:lvar, :lvasgn).any? do |lvar|
             !lvar.parent.block_pass_type? && lvar.node_parts[0].to_s == last_argument
           end
         end