rubocop 1.65.1 → 1.75.6

data/lib/rubocop/rspec/shared_contexts.rb

@@ -80,15 +80,30 @@ RSpec.shared_context 'maintain registry' do
   end
 end
 
+RSpec.shared_context 'maintain default configuration' do
+  around(:each) do |example|
+    # Make a copy of the current configuration that will not change when source hash changes
+    default_configuration = RuboCop::ConfigLoader.default_configuration
+    config = RuboCop::Config.create(
+      default_configuration.to_h.clone,
+      default_configuration.loaded_path
+    )
+
+    example.run
+
+    RuboCop::ConfigLoader.instance_variable_set(:@default_configuration, config)
+  end
+end
+
 # This context assumes nothing and defines `cop`, among others.
 RSpec.shared_context 'config' do # rubocop:disable Metrics/BlockLength
   ### Meant to be overridden at will
 
   let(:cop_class) do
     unless described_class.is_a?(Class) && described_class < RuboCop::Cop::Base
-      raise 'Specify which cop class to use (e.g `let(:cop_class) { RuboCop::Cop::Base }`, ' \
-            'or RuboCop::Cop::Cop for legacy)'
+      raise 'Specify which cop class to use (e.g `let(:cop_class) { RuboCop::Cop::Base }`)'
     end
+
     described_class
   end
 
@@ -98,6 +113,8 @@ RSpec.shared_context 'config' do # rubocop:disable Metrics/BlockLength
 
   let(:cop_options) { {} }
 
+  let(:gem_versions) { {} }
+
   ### Utilities
 
   def source_range(range, buffer: source_buffer)
@@ -138,7 +155,8 @@ RSpec.shared_context 'config' do # rubocop:disable Metrics/BlockLength
 
     allow(config).to receive(:gem_versions_in_target).and_return(
       {
-        'railties' => rails_version_in_gemfile
+        'railties' => rails_version_in_gemfile,
+        **gem_versions.transform_values { |value| Gem::Version.new(value) }
       }
     )
 
@@ -160,6 +178,21 @@ RSpec.shared_context 'mock console output' do
   end
 end
 
+RSpec.shared_context 'mock obsoletion' do
+  include_context 'mock console output'
+
+  let(:obsoletion_configuration_path) { 'obsoletions.yml' }
+
+  before do
+    RuboCop::ConfigObsoletion.reset!
+    allow(RuboCop::ConfigObsoletion).to receive(:files).and_return([obsoletion_configuration_path])
+  end
+
+  after do
+    RuboCop::ConfigObsoletion.reset!
+  end
+end
+
 RSpec.shared_context 'lsp' do
   before do
     RuboCop::LSP.enable
@@ -232,3 +265,7 @@ end
 RSpec.shared_context 'ruby 3.4' do
   let(:ruby_version) { 3.4 }
 end
+
+RSpec.shared_context 'ruby 3.5' do
+  let(:ruby_version) { 3.5 }
+end

data/lib/rubocop/rspec/support.rb

@@ -4,18 +4,19 @@
 
 require_relative 'cop_helper'
 require_relative 'expect_offense'
-require_relative 'host_environment_simulation_helper'
 require_relative 'parallel_formatter'
 require_relative 'shared_contexts'
 
 RSpec.configure do |config|
   config.include CopHelper
-  config.include HostEnvironmentSimulatorHelper
+  config.include RuboCop::RSpec::ExpectOffense
   config.include_context 'config', :config
   config.include_context 'isolated environment', :isolated_environment
   config.include_context 'isolated bundler', :isolated_bundler
   config.include_context 'lsp', :lsp
   config.include_context 'maintain registry', :restore_registry
+  config.include_context 'maintain default configuration', :restore_configuration
+  config.include_context 'mock obsoletion', :mock_obsoletion
   config.include_context 'ruby 2.0', :ruby20
   config.include_context 'ruby 2.1', :ruby21
   config.include_context 'ruby 2.2', :ruby22
@@ -29,4 +30,5 @@ RSpec.configure do |config|
   config.include_context 'ruby 3.2', :ruby32
   config.include_context 'ruby 3.3', :ruby33
   config.include_context 'ruby 3.4', :ruby34
+  config.include_context 'ruby 3.5', :ruby35
 end

data/lib/rubocop/runner.rb

@@ -20,11 +20,7 @@ module RuboCop
         message = 'Infinite loop detected'
         message += " in #{path}" if path
         message += " and caused by #{root_cause}" if root_cause
-        message += "\n"
-        hint = 'Hint: Please update to the latest RuboCop version if not already in use, ' \
-               "and report a bug if the issue still occurs on this version.\n" \
-               'Please check the latest version at https://rubygems.org/gems/rubocop.'
-        super(Rainbow(message).red + Rainbow(hint).yellow)
+        super(message)
       end
     end
 
@@ -139,7 +135,7 @@ module RuboCop
         offenses = process_file(file)
         yield file
 
-        if offenses.any? { |o| considered_failure?(o) }
+        if offenses.any? { |o| considered_failure?(o) && offense_displayed?(o) }
           break false if @options[:fail_fast]
 
           next false
@@ -157,8 +153,11 @@ module RuboCop
       file_started(file)
       offenses = file_offenses(file)
     rescue InfiniteCorrectionLoop => e
+      raise e if @options[:raise_cop_error]
+
+      errors << e
+      warn Rainbow(e.message).red
       offenses = e.offenses.compact.sort.freeze
-      raise
     ensure
       file_finished(file, offenses || [])
     end
@@ -362,6 +361,13 @@ module RuboCop
       self.class.ruby_extractors.find do |ruby_extractor|
         result = ruby_extractor.call(processed_source)
         break result if result
+      rescue StandardError
+        location = if ruby_extractor.is_a?(Proc)
+                     ruby_extractor.source_location
+                   else
+                     ruby_extractor.method(:call).source_location
+                   end
+        raise Error, "Ruby extractor #{location[0]} failed to process #{processed_source.path}."
       end
     end
 
@@ -433,18 +439,22 @@ module RuboCop
       !offense.corrected? && offense.severity >= minimum_severity_to_fail
     end
 
-    def offenses_to_report(offenses)
+    def offense_displayed?(offense)
       if @options[:display_only_fail_level_offenses]
-        offenses.select { |o| considered_failure?(o) }
+        considered_failure?(offense)
       elsif @options[:display_only_safe_correctable]
-        offenses.select { |o| supports_safe_autocorrect?(o) }
+        supports_safe_autocorrect?(offense)
       elsif @options[:display_only_correctable]
-        offenses.select(&:correctable?)
+        offense.correctable?
       else
-        offenses
+        true
       end
     end
 
+    def offenses_to_report(offenses)
+      offenses.select { |o| offense_displayed?(o) }
+    end
+
     def supports_safe_autocorrect?(offense)
       cop_class = Cop::Registry.global.find_by_cop_name(offense.cop_name)
       default_cfg = default_config(offense.cop_name)
@@ -479,7 +489,11 @@ module RuboCop
 
       processed_source = if @options[:stdin]
                            ProcessedSource.new(
-                             @options[:stdin], ruby_version, file, parser_engine: parser_engine
+                             @options[:stdin],
+                             ruby_version,
+                             file,
+                             parser_engine: parser_engine,
+                             prism_result: @prism_result
                            )
                          else
                            begin

data/lib/rubocop/server/cache.rb

@@ -2,8 +2,10 @@
 
 require 'digest'
 require 'pathname'
+require 'yaml'
 require_relative '../cache_config'
 require_relative '../config_finder'
+require_relative '../path_util'
 
 #
 # This code is based on https://github.com/fohte/rubocop-daemon.
@@ -43,13 +45,21 @@ module RuboCop
           @project_dir_cache_key ||= project_dir[1..].tr('/', '+')
         end
 
+        # rubocop:disable Metrics/AbcSize
         def restart_key
           lockfile_path = LOCKFILE_NAMES.map do |lockfile_name|
             Pathname(project_dir).join(lockfile_name)
           end.find(&:exist?)
+          version_data = lockfile_path&.read || RuboCop::Version::STRING
+          config_data = Pathname(ConfigFinder.find_config_path(Dir.pwd)).read
+          yaml = load_erb_templated_yaml(config_data)
 
-          Digest::SHA1.hexdigest(lockfile_path&.read || RuboCop::Version::STRING)
+          inherit_from_data = inherit_from_data(yaml)
+          require_data = require_data(yaml)
+
+          Digest::SHA1.hexdigest(version_data + config_data + inherit_from_data + require_data)
         end
+        # rubocop:enable Metrics/AbcSize
 
         def dir
           Pathname.new(File.join(cache_path, project_dir_cache_key)).tap do |d|
@@ -67,7 +77,6 @@ module RuboCop
           File.expand_path(File.join(cache_root_dir, 'server'))
         end
 
-        # rubocop:disable Metrics/MethodLength
         def cache_root_dir_from_config
           CacheConfig.root_dir do
             # `RuboCop::ConfigStore` has heavy dependencies, this is a lightweight implementation
@@ -78,13 +87,7 @@ module RuboCop
             # Returns early if `CacheRootDirectory` is not used before requiring `erb` or `yaml`.
             next unless file_contents.include?('CacheRootDirectory')
 
-            require 'erb'
-            yaml_code = ERB.new(file_contents).result
-
-            require 'yaml'
-            config_yaml = YAML.safe_load(
-              yaml_code, permitted_classes: [Regexp, Symbol], aliases: true
-            )
+            config_yaml = load_erb_templated_yaml(file_contents)
 
             # For compatibility with Ruby 3.0 or lower.
             if Gem::Version.new(Psych::VERSION) < Gem::Version.new('4.0.0')
@@ -94,7 +97,6 @@ module RuboCop
             config_yaml&.dig('AllCops', 'CacheRootDirectory')
           end
         end
-        # rubocop:enable Metrics/MethodLength
 
         def port_path
           dir.join('port')
@@ -126,7 +128,7 @@ module RuboCop
 
         def pid_running?
           Process.kill(0, pid_path.read.to_i) == 1
-        rescue Errno::ESRCH, Errno::ENOENT, Errno::EACCES, Errno::EROFS
+        rescue Errno::ESRCH, Errno::ENOENT, Errno::EACCES, Errno::EROFS, Errno::ENAMETOOLONG
           false
         end
 
@@ -159,6 +161,45 @@ module RuboCop
         def write_version_file(version)
           version_path.write(version)
         end
+
+        def inherit_from_data(yaml)
+          return '' unless (inherit_from_paths = yaml['inherit_from'])
+
+          Array(inherit_from_paths).map do |path|
+            next if PathUtil.remote_file?(path)
+
+            path = Pathname(path)
+
+            path.exist? ? path.read : ''
+          end.join
+        end
+
+        def require_data(yaml)
+          return '' unless (require_paths = yaml['require'])
+
+          Array(require_paths).map do |path|
+            # NOTE: This targets only relative or absolute path specifications.
+            # For example, specifications like `require: rubocop-performance`,
+            # which can be loaded from `$LOAD_PATH`, are ignored.
+            next unless path.start_with?('.', '/')
+
+            # NOTE: `.so` files are not typically specified, so only `.rb` files are targeted.
+            path = "#{path}.rb" unless path.end_with?('.rb')
+            path = Pathname(path)
+
+            path.exist? ? path.read : ''
+          end.join
+        end
+
+        private
+
+        def load_erb_templated_yaml(content)
+          require 'erb'
+          yaml_code = ERB.new(content).result
+
+          require 'yaml'
+          YAML.safe_load(yaml_code, permitted_classes: [Regexp, Symbol], aliases: true)
+        end
       end
     end
   end

data/lib/rubocop/server/cli.rb

@@ -86,7 +86,7 @@ module RuboCop
       end
       # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
 
-      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength:
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
       def run_command(server_command, detach:)
         case server_command
         when '--server'
@@ -107,7 +107,7 @@ module RuboCop
           Server::ClientCommand::Status.new.run
         end
       end
-      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength:
+      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength
 
       def fetch_cache_root_path_from(arguments)
         cache_root = arguments.detect { |argument| argument.start_with?('--cache-root') }

data/lib/rubocop/server/core.rb

@@ -2,6 +2,7 @@
 
 require 'securerandom'
 require 'socket'
+require 'stringio'
 
 #
 # This code is based on https://github.com/fohte/rubocop-daemon.

data/lib/rubocop/target_finder.rb

@@ -46,7 +46,11 @@ module RuboCop
       hidden_files = all_files.select { |file| file.include?(HIDDEN_PATH_SUBSTRING) }.sort
       base_dir_config = @config_store.for(base_dir)
 
-      target_files = all_files.select { |file| to_inspect?(file, hidden_files, base_dir_config) }
+      target_files = if base_dir.include?(HIDDEN_PATH_SUBSTRING)
+                       all_files.select { |file| ruby_file?(file) }
+                     else
+                       all_files.select { |file| to_inspect?(file, hidden_files, base_dir_config) }
+                     end
 
       target_files.sort_by!(&order)
     end
@@ -127,6 +131,7 @@ module RuboCop
       if mode == :only_recognized_file_types || force_exclusion?
         files.select! { |file| included_file?(file) }
       end
+      files.reject! { |file| FileTest.directory?(file) }
 
       force_exclusion? ? without_excluded(files) : files
     end
@@ -174,7 +179,7 @@ module RuboCop
     end
 
     def ruby_executable?(file)
-      return false unless File.extname(file).empty? && File.exist?(file)
+      return false if !File.extname(file).empty? || !File.exist?(file) || File.empty?(file)
 
       first_line = File.open(file, &:readline)
       /#!.*(#{ruby_interpreters(file).join('|')})/.match?(first_line)

data/lib/rubocop/target_ruby.rb

@@ -4,7 +4,7 @@ module RuboCop
   # The kind of Ruby that code inspected by RuboCop is written in.
   # @api private
   class TargetRuby
-    KNOWN_RUBIES = [2.0, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 3.0, 3.1, 3.2, 3.3, 3.4].freeze
+    KNOWN_RUBIES = [2.0, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 3.0, 3.1, 3.2, 3.3, 3.4, 3.5].freeze
     DEFAULT_VERSION = 2.7
 
     OBSOLETE_RUBIES = {
@@ -34,6 +34,20 @@ module RuboCop
       end
     end
 
+    # The target ruby version may be configured by setting the
+    # `RUBOCOP_TARGET_RUBY_VERSION` environment variable.
+    class RuboCopEnvVar < Source
+      def name
+        '`RUBOCOP_TARGET_RUBY_VERSION` environment variable'
+      end
+
+      private
+
+      def find_version
+        ENV.fetch('RUBOCOP_TARGET_RUBY_VERSION', nil)&.to_f
+      end
+    end
+
     # The target ruby version may be configured in RuboCop's config.
     # @api private
     class RuboCopConfig < Source
@@ -53,8 +67,6 @@ module RuboCop
     class GemspecFile < Source
       extend NodePattern::Macros
 
-      GEMSPEC_EXTENSION = '.gemspec'
-
       # @!method required_ruby_version(node)
       def_node_search :required_ruby_version, <<~PATTERN
         (send _ :required_ruby_version= $_)
@@ -68,7 +80,7 @@ module RuboCop
       PATTERN
 
       def name
-        "`required_ruby_version` parameter (in #{gemspec_filename})"
+        "`required_ruby_version` parameter (in #{gemspec_filepath})"
       end
 
       private
@@ -80,25 +92,29 @@ module RuboCop
         right_hand_side = version_from_gemspec_file(file)
         return if right_hand_side.nil?
 
-        find_default_minimal_known_ruby(right_hand_side)
-      end
-
-      def gemspec_filename
-        @gemspec_filename ||= begin
-          basename = Pathname.new(@config.base_dir_for_path_parameters).basename.to_s
-          "#{basename}#{GEMSPEC_EXTENSION}"
-        end
+        find_minimal_known_ruby(right_hand_side)
       end
 
       def gemspec_filepath
-        @gemspec_filepath ||=
-          @config.find_file_upwards(gemspec_filename, @config.base_dir_for_path_parameters)
+        return @gemspec_filepath if defined?(@gemspec_filepath)
+
+        @gemspec_filepath =
+          @config.traverse_directories_upwards(@config.base_dir_for_path_parameters) do |dir|
+            # NOTE: Can't use `dir.glob` because of JRuby 9.4.8.0 incompatibility:
+            # https://github.com/jruby/jruby/issues/8358
+            candidates = Pathname.glob("#{dir}/*.gemspec")
+            # Bundler will use a gemspec whatever the filename is, as long as its the only one in
+            # the folder.
+            break candidates.first if candidates.one?
+          end
       end
 
       def version_from_gemspec_file(file)
         processed_source = ProcessedSource.from_file(
           file, DEFAULT_VERSION, parser_engine: @config.parser_engine
         )
+        return unless processed_source.valid_syntax?
+
         required_ruby_version(processed_source.ast).first
       end
 
@@ -118,12 +134,14 @@ module RuboCop
         array.children.map(&:value)
       end
 
-      def find_default_minimal_known_ruby(right_hand_side)
+      def find_minimal_known_ruby(right_hand_side)
         version = version_from_right_hand_side(right_hand_side)
+        return unless version
+
         requirement = Gem::Requirement.new(version)
 
         KNOWN_RUBIES.detect do |v|
-          v >= DEFAULT_VERSION && requirement.satisfied_by?(Gem::Version.new("#{v}.99"))
+          requirement.satisfied_by?(Gem::Version.new("#{v}.99"))
         end
       end
     end
@@ -242,6 +260,7 @@ module RuboCop
     end
 
     SOURCES = [
+      RuboCopEnvVar,
       RuboCopConfig,
       GemspecFile,
       RubyVersionFile,
@@ -269,7 +288,7 @@ module RuboCop
 
     def rubocop_version_with_support
       if supported?
-        RuboCop::Version.version
+        RuboCop::Version::STRING
       else
         OBSOLETE_RUBIES[version]
       end

data/lib/rubocop/version.rb

@@ -3,12 +3,15 @@
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '1.65.1'
+    STRING = '1.75.6'
 
     MSG = '%<version>s (using %<parser_version>s, ' \
           'rubocop-ast %<rubocop_ast_version>s, ' \
+          'analyzing as Ruby %<target_ruby_version>s, ' \
           'running on %<ruby_engine>s %<ruby_version>s)%<server_mode>s [%<ruby_platform>s]'
 
+    MINIMUM_PARSABLE_PRISM_VERSION = 3.3
+
     CANONICAL_FEATURE_NAMES = {
       'Rspec' => 'RSpec', 'Graphql' => 'GraphQL', 'Md' => 'Markdown', 'Factory_bot' => 'FactoryBot',
       'Thread_safety' => 'ThreadSafety', 'Rspec_rails' => 'RSpecRails'
@@ -17,11 +20,16 @@ module RuboCop
       'rubocop-md' => 'markdown', 'rubocop-factory_bot' => 'factory_bot'
     }.freeze
 
+    # NOTE: Marked as private but used by gems like standard.
     # @api private
+    # rubocop:disable Metrics/MethodLength
     def self.version(debug: false, env: nil)
       if debug
-        verbose_version = format(MSG, version: STRING, parser_version: parser_version,
+        target_ruby_version = target_ruby_version(env)
+        verbose_version = format(MSG, version: STRING,
+                                      parser_version: parser_version(target_ruby_version),
                                       rubocop_ast_version: RuboCop::AST::Version::STRING,
+                                      target_ruby_version: target_ruby_version,
                                       ruby_engine: RUBY_ENGINE, ruby_version: RUBY_VERSION,
                                       server_mode: server_mode,
                                       ruby_platform: RUBY_PLATFORM)
@@ -38,31 +46,45 @@ module RuboCop
         STRING
       end
     end
+    # rubocop:enable Metrics/MethodLength
 
     # @api private
-    def self.parser_version
+    def self.verbose(env: nil)
+      version(debug: true, env: env)
+    end
+
+    # @api private
+    def self.parser_version(target_ruby_version)
       config_path = ConfigFinder.find_config_path(Dir.pwd)
       yaml = Util.silence_warnings do
         ConfigLoader.load_yaml_configuration(config_path)
       end
+      parser_engine = yaml.dig('AllCops', 'ParserEngine')
+      parser_engine_text = ", #{parser_engine}" if parser_engine
 
-      if yaml.dig('AllCops', 'ParserEngine') == 'parser_prism'
-        require 'prism'
-        "Prism #{Prism::VERSION}"
+      if target_ruby_version >= MINIMUM_PARSABLE_PRISM_VERSION
+        "Parser #{Parser::VERSION}, Prism #{Prism::VERSION}#{parser_engine_text}"
       else
         "Parser #{Parser::VERSION}"
       end
     end
 
     # @api private
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
     def self.extension_versions(env)
-      features = Util.silence_warnings do
-        # Suppress any config issues when loading the config (ie. deprecations,
-        # pending cops, etc.).
-        env.config_store.unvalidated.for_pwd.loaded_features.sort
+      plugins = config_for_pwd(env).loaded_plugins
+      plugin_versions = plugins.filter_map do |plugin|
+        next if Plugin::BUILTIN_INTERNAL_PLUGINS.key?(plugin.about.name)
+        next unless (plugin_name = plugin.about.name)
+
+        "  - #{plugin_name} #{plugin.about.version}"
       end
 
-      features.filter_map do |loaded_feature|
+      # TODO: It needs to be maintained for a while to ensure compatibility with extensions that
+      # don't support plugins. It should be removed in future once the old style becomes obsolete.
+      features = config_for_pwd(env).loaded_features.sort
+      features -= plugins.map { |plugin| plugin.about.name }
+      feature_versions = features.filter_map do |loaded_feature|
         next unless (match = loaded_feature.match(/rubocop-(?<feature>.*)/))
 
         # Get the expected name of the folder containing the extension code.
@@ -81,6 +103,27 @@ module RuboCop
 
         "  - #{loaded_feature} #{feature_version}"
       end
+
+      plugin_versions + feature_versions
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+
+    # @api private
+    def self.target_ruby_version(env)
+      if env
+        config_for_pwd(env).target_ruby_version
+      else
+        TargetRuby.new(Config.new).version
+      end
+    end
+
+    # @api private
+    def self.config_for_pwd(env)
+      Util.silence_warnings do
+        # Suppress any config issues when loading the config (ie. deprecations,
+        # pending cops, etc.).
+        env.config_store.unvalidated.for_pwd
+      end
     end
 
     # Returns feature version in one of two ways:

data/lib/rubocop/yaml_duplication_checker.rb

@@ -5,36 +5,30 @@ module RuboCop
   # @api private
   module YAMLDuplicationChecker
     def self.check(yaml_string, filename, &on_duplicated)
-      # Ruby 2.6+
-      tree = if Gem::Version.new(Psych::VERSION) >= Gem::Version.new('3.1.0')
-               # Specify filename to display helpful message when it raises
-               # an error.
-               YAML.parse(yaml_string, filename: filename)
-             else
-               YAML.parse(yaml_string, filename)
-             end
-      return unless tree
-
-      traverse(tree, &on_duplicated)
+      handler = DuplicationCheckHandler.new(&on_duplicated)
+      parser = Psych::Parser.new(handler)
+      parser.parse(yaml_string, filename)
+      parser.handler.root.children[0]
     end
 
-    def self.traverse(tree, &on_duplicated)
-      case tree
-      when Psych::Nodes::Mapping
-        tree.children.each_slice(2).with_object([]) do |(key, value), keys|
-          exist = keys.find { |key2| key2.value == key.value }
-          yield(exist, key) if exist
-          keys << key
-          traverse(value, &on_duplicated)
-        end
-      else
-        children = tree.children
-        return unless children
+    class DuplicationCheckHandler < Psych::TreeBuilder # :nodoc:
+      def initialize(&block)
+        super()
+        @block = block
+      end
 
-        children.each { |c| traverse(c, &on_duplicated) }
+      def end_mapping
+        mapping_node = super
+        # OPTIMIZE: Use a hash for faster lookup since there can
+        # be quite a few keys at the top-level.
+        keys = {}
+        mapping_node.children.each_slice(2) do |key, _value|
+          duplicate = keys[key.value]
+          @block.call(duplicate, key) if duplicate
+          keys[key.value] = key
+        end
+        mapping_node
       end
     end
-
-    private_class_method :traverse
   end
 end