did_you_mean 1.5.0 → 1.6.2

data/test/lib/envutil.rb

@@ -0,0 +1,372 @@
+# -*- coding: us-ascii -*-
+# frozen_string_literal: true
+require "open3"
+require "timeout"
+require_relative "find_executable"
+begin
+  require 'rbconfig'
+rescue LoadError
+end
+begin
+  require "rbconfig/sizeof"
+rescue LoadError
+end
+
+module EnvUtil
+  def rubybin
+    if ruby = ENV["RUBY"]
+      return ruby
+    end
+    ruby = "ruby"
+    exeext = RbConfig::CONFIG["EXEEXT"]
+    rubyexe = (ruby + exeext if exeext and !exeext.empty?)
+    3.times do
+      if File.exist? ruby and File.executable? ruby and !File.directory? ruby
+        return File.expand_path(ruby)
+      end
+      if rubyexe and File.exist? rubyexe and File.executable? rubyexe
+        return File.expand_path(rubyexe)
+      end
+      ruby = File.join("..", ruby)
+    end
+    if defined?(RbConfig.ruby)
+      RbConfig.ruby
+    else
+      "ruby"
+    end
+  end
+  module_function :rubybin
+
+  LANG_ENVS = %w"LANG LC_ALL LC_CTYPE"
+
+  DEFAULT_SIGNALS = Signal.list
+  DEFAULT_SIGNALS.delete("TERM") if /mswin|mingw/ =~ RUBY_PLATFORM
+
+  RUBYLIB = ENV["RUBYLIB"]
+
+  class << self
+    attr_accessor :timeout_scale
+    attr_reader :original_internal_encoding, :original_external_encoding,
+                :original_verbose, :original_warning
+
+    def capture_global_values
+      @original_internal_encoding = Encoding.default_internal
+      @original_external_encoding = Encoding.default_external
+      @original_verbose = $VERBOSE
+      @original_warning = defined?(Warning.[]) ? %i[deprecated experimental].to_h {|i| [i, Warning[i]]} : nil
+    end
+  end
+
+  def apply_timeout_scale(t)
+    if scale = EnvUtil.timeout_scale
+      t * scale
+    else
+      t
+    end
+  end
+  module_function :apply_timeout_scale
+
+  def timeout(sec, klass = nil, message = nil, &blk)
+    return yield(sec) if sec == nil or sec.zero?
+    sec = apply_timeout_scale(sec)
+    Timeout.timeout(sec, klass, message, &blk)
+  end
+  module_function :timeout
+
+  def terminate(pid, signal = :TERM, pgroup = nil, reprieve = 1)
+    reprieve = apply_timeout_scale(reprieve) if reprieve
+
+    signals = Array(signal).select do |sig|
+      DEFAULT_SIGNALS[sig.to_s] or
+        DEFAULT_SIGNALS[Signal.signame(sig)] rescue false
+    end
+    signals |= [:ABRT, :KILL]
+    case pgroup
+    when 0, true
+      pgroup = -pid
+    when nil, false
+      pgroup = pid
+    end
+
+    lldb = true if /darwin/ =~ RUBY_PLATFORM
+
+    while signal = signals.shift
+
+      if lldb and [:ABRT, :KILL].include?(signal)
+        lldb = false
+        # sudo -n: --non-interactive
+        # lldb -p: attach
+        #      -o: run command
+        system(*%W[sudo -n lldb -p #{pid} --batch -o bt\ all -o call\ rb_vmdebug_stack_dump_all_threads() -o quit])
+        true
+      end
+
+      begin
+        Process.kill signal, pgroup
+      rescue Errno::EINVAL
+        next
+      rescue Errno::ESRCH
+        break
+      end
+      if signals.empty? or !reprieve
+        Process.wait(pid)
+      else
+        begin
+          Timeout.timeout(reprieve) {Process.wait(pid)}
+        rescue Timeout::Error
+        else
+          break
+        end
+      end
+    end
+    $?
+  end
+  module_function :terminate
+
+  def invoke_ruby(args, stdin_data = "", capture_stdout = false, capture_stderr = false,
+                  encoding: nil, timeout: 10, reprieve: 1, timeout_error: Timeout::Error,
+                  stdout_filter: nil, stderr_filter: nil, ios: nil,
+                  signal: :TERM,
+                  rubybin: EnvUtil.rubybin, precommand: nil,
+                  **opt)
+    timeout = apply_timeout_scale(timeout)
+
+    in_c, in_p = IO.pipe
+    out_p, out_c = IO.pipe if capture_stdout
+    err_p, err_c = IO.pipe if capture_stderr && capture_stderr != :merge_to_stdout
+    opt[:in] = in_c
+    opt[:out] = out_c if capture_stdout
+    opt[:err] = capture_stderr == :merge_to_stdout ? out_c : err_c if capture_stderr
+    if encoding
+      out_p.set_encoding(encoding) if out_p
+      err_p.set_encoding(encoding) if err_p
+    end
+    ios.each {|i, o = i|opt[i] = o} if ios
+
+    c = "C"
+    child_env = {}
+    LANG_ENVS.each {|lc| child_env[lc] = c}
+    if Array === args and Hash === args.first
+      child_env.update(args.shift)
+    end
+    if RUBYLIB and lib = child_env["RUBYLIB"]
+      child_env["RUBYLIB"] = [lib, RUBYLIB].join(File::PATH_SEPARATOR)
+    end
+
+    # remain env
+    %w(ASAN_OPTIONS RUBY_ON_BUG).each{|name|
+      child_env[name] = ENV[name] if ENV[name]
+    }
+
+    args = [args] if args.kind_of?(String)
+    pid = spawn(child_env, *precommand, rubybin, *args, opt)
+    in_c.close
+    out_c&.close
+    out_c = nil
+    err_c&.close
+    err_c = nil
+    if block_given?
+      return yield in_p, out_p, err_p, pid
+    else
+      th_stdout = Thread.new { out_p.read } if capture_stdout
+      th_stderr = Thread.new { err_p.read } if capture_stderr && capture_stderr != :merge_to_stdout
+      in_p.write stdin_data.to_str unless stdin_data.empty?
+      in_p.close
+      if (!th_stdout || th_stdout.join(timeout)) && (!th_stderr || th_stderr.join(timeout))
+        timeout_error = nil
+      else
+        status = terminate(pid, signal, opt[:pgroup], reprieve)
+        terminated = Time.now
+      end
+      stdout = th_stdout.value if capture_stdout
+      stderr = th_stderr.value if capture_stderr && capture_stderr != :merge_to_stdout
+      out_p.close if capture_stdout
+      err_p.close if capture_stderr && capture_stderr != :merge_to_stdout
+      status ||= Process.wait2(pid)[1]
+      stdout = stdout_filter.call(stdout) if stdout_filter
+      stderr = stderr_filter.call(stderr) if stderr_filter
+      if timeout_error
+        bt = caller_locations
+        msg = "execution of #{bt.shift.label} expired timeout (#{timeout} sec)"
+        msg = failure_description(status, terminated, msg, [stdout, stderr].join("\n"))
+        raise timeout_error, msg, bt.map(&:to_s)
+      end
+      return stdout, stderr, status
+    end
+  ensure
+    [th_stdout, th_stderr].each do |th|
+      th.kill if th
+    end
+    [in_c, in_p, out_c, out_p, err_c, err_p].each do |io|
+      io&.close
+    end
+    [th_stdout, th_stderr].each do |th|
+      th.join if th
+    end
+  end
+  module_function :invoke_ruby
+
+  def verbose_warning
+    class << (stderr = "".dup)
+      alias write concat
+      def flush; end
+    end
+    stderr, $stderr = $stderr, stderr
+    $VERBOSE = true
+    yield stderr
+    return $stderr
+  ensure
+    stderr, $stderr = $stderr, stderr
+    $VERBOSE = EnvUtil.original_verbose
+    EnvUtil.original_warning&.each {|i, v| Warning[i] = v}
+  end
+  module_function :verbose_warning
+
+  def default_warning
+    $VERBOSE = false
+    yield
+  ensure
+    $VERBOSE = EnvUtil.original_verbose
+  end
+  module_function :default_warning
+
+  def suppress_warning
+    $VERBOSE = nil
+    yield
+  ensure
+    $VERBOSE = EnvUtil.original_verbose
+  end
+  module_function :suppress_warning
+
+  def under_gc_stress(stress = true)
+    stress, GC.stress = GC.stress, stress
+    yield
+  ensure
+    GC.stress = stress
+  end
+  module_function :under_gc_stress
+
+  def with_default_external(enc)
+    suppress_warning { Encoding.default_external = enc }
+    yield
+  ensure
+    suppress_warning { Encoding.default_external = EnvUtil.original_external_encoding }
+  end
+  module_function :with_default_external
+
+  def with_default_internal(enc)
+    suppress_warning { Encoding.default_internal = enc }
+    yield
+  ensure
+    suppress_warning { Encoding.default_internal = EnvUtil.original_internal_encoding }
+  end
+  module_function :with_default_internal
+
+  def labeled_module(name, &block)
+    Module.new do
+      singleton_class.class_eval {
+        define_method(:to_s) {name}
+        alias inspect to_s
+        alias name to_s
+      }
+      class_eval(&block) if block
+    end
+  end
+  module_function :labeled_module
+
+  def labeled_class(name, superclass = Object, &block)
+    Class.new(superclass) do
+      singleton_class.class_eval {
+        define_method(:to_s) {name}
+        alias inspect to_s
+        alias name to_s
+      }
+      class_eval(&block) if block
+    end
+  end
+  module_function :labeled_class
+
+  if /darwin/ =~ RUBY_PLATFORM
+    DIAGNOSTIC_REPORTS_PATH = File.expand_path("~/Library/Logs/DiagnosticReports")
+    DIAGNOSTIC_REPORTS_TIMEFORMAT = '%Y-%m-%d-%H%M%S'
+    @ruby_install_name = RbConfig::CONFIG['RUBY_INSTALL_NAME']
+
+    def self.diagnostic_reports(signame, pid, now)
+      return unless %w[ABRT QUIT SEGV ILL TRAP].include?(signame)
+      cmd = File.basename(rubybin)
+      cmd = @ruby_install_name if "ruby-runner#{RbConfig::CONFIG["EXEEXT"]}" == cmd
+      path = DIAGNOSTIC_REPORTS_PATH
+      timeformat = DIAGNOSTIC_REPORTS_TIMEFORMAT
+      pat = "#{path}/#{cmd}_#{now.strftime(timeformat)}[-_]*.crash"
+      first = true
+      30.times do
+        first ? (first = false) : sleep(0.1)
+        Dir.glob(pat) do |name|
+          log = File.read(name) rescue next
+          if /\AProcess:\s+#{cmd} \[#{pid}\]$/ =~ log
+            File.unlink(name)
+            File.unlink("#{path}/.#{File.basename(name)}.plist") rescue nil
+            return log
+          end
+        end
+      end
+      nil
+    end
+  else
+    def self.diagnostic_reports(signame, pid, now)
+    end
+  end
+
+  def self.failure_description(status, now, message = "", out = "")
+    pid = status.pid
+    if signo = status.termsig
+      signame = Signal.signame(signo)
+      sigdesc = "signal #{signo}"
+    end
+    log = diagnostic_reports(signame, pid, now)
+    if signame
+      sigdesc = "SIG#{signame} (#{sigdesc})"
+    end
+    if status.coredump?
+      sigdesc = "#{sigdesc} (core dumped)"
+    end
+    full_message = ''.dup
+    message = message.call if Proc === message
+    if message and !message.empty?
+      full_message << message << "\n"
+    end
+    full_message << "pid #{pid}"
+    full_message << " exit #{status.exitstatus}" if status.exited?
+    full_message << " killed by #{sigdesc}" if sigdesc
+    if out and !out.empty?
+      full_message << "\n" << out.b.gsub(/^/, '| ')
+      full_message.sub!(/(?<!\n)\z/, "\n")
+    end
+    if log
+      full_message << "Diagnostic reports:\n" << log.b.gsub(/^/, '| ')
+    end
+    full_message
+  end
+
+  def self.gc_stress_to_class?
+    unless defined?(@gc_stress_to_class)
+      _, _, status = invoke_ruby(["-e""exit GC.respond_to?(:add_stress_to_class)"])
+      @gc_stress_to_class = status.success?
+    end
+    @gc_stress_to_class
+  end
+end
+
+if defined?(RbConfig)
+  module RbConfig
+    @ruby = EnvUtil.rubybin
+    class << self
+      undef ruby if method_defined?(:ruby)
+      attr_reader :ruby
+    end
+    dir = File.dirname(ruby)
+    CONFIG['bindir'] = dir
+  end
+end
+
+EnvUtil.capture_global_values

data/test/lib/find_executable.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+require "rbconfig"
+
+module EnvUtil
+  def find_executable(cmd, *args)
+    exts = RbConfig::CONFIG["EXECUTABLE_EXTS"].split | [RbConfig::CONFIG["EXEEXT"]]
+    ENV["PATH"].split(File::PATH_SEPARATOR).each do |path|
+      next if path.empty?
+      path = File.join(path, cmd)
+      exts.each do |ext|
+        cmdline = [path + ext, *args]
+        begin
+          return cmdline if yield(IO.popen(cmdline, "r", err: [:child, :out], &:read))
+        rescue
+          next
+        end
+      end
+    end
+    nil
+  end
+  module_function :find_executable
+end

data/test/lib/helper.rb

@@ -0,0 +1,3 @@
+require "test/unit"
+require_relative "core_assertions"
+Test::Unit::TestCase.include Test::Unit::CoreAssertions

data/test/spell_checking/test_key_name_check.rb

@@ -8,11 +8,11 @@ class KeyNameCheckTest < Test::Unit::TestCase
 
     error = assert_raise(KeyError) { hash.fetch(:bax) }
     assert_correction ":bar", error.corrections
-    assert_match "Did you mean?  :bar", error.to_s
+    assert_match "Did you mean?  :bar", get_message(error)
 
     error = assert_raise(KeyError) { hash.fetch("fooo") }
     assert_correction %("foo"), error.corrections
-    assert_match %(Did you mean?  "foo"), error.to_s
+    assert_match %(Did you mean?  "foo"), get_message(error)
   end
 
   def test_corrects_hash_key_name_with_fetch_values
@@ -20,11 +20,11 @@ class KeyNameCheckTest < Test::Unit::TestCase
 
     error = assert_raise(KeyError) { hash.fetch_values("foo", :bar, :bax) }
     assert_correction ":bar", error.corrections
-    assert_match "Did you mean?  :bar", error.to_s
+    assert_match "Did you mean?  :bar", get_message(error)
 
     error = assert_raise(KeyError) { hash.fetch_values("foo", :bar, "fooo") }
     assert_correction %("foo"), error.corrections
-    assert_match %(Did you mean?  "foo"), error.to_s
+    assert_match %(Did you mean?  "foo"), get_message(error)
   end
 
   def test_correct_symbolized_hash_keys_with_string_value
@@ -32,13 +32,13 @@ class KeyNameCheckTest < Test::Unit::TestCase
 
     error = assert_raise(KeyError) { hash.fetch('foo_1') }
     assert_correction %(:foo_1), error.corrections
-    assert_match %(Did you mean?  :foo_1), error.to_s
+    assert_match %(Did you mean?  :foo_1), get_message(error)
   end
 
   def test_corrects_sprintf_key_name
     error = assert_raise(KeyError) { sprintf("%<foo>d", {fooo: 1}) }
     assert_correction ":fooo", error.corrections
-    assert_match "Did you mean?  :fooo", error.to_s
+    assert_match "Did you mean?  :fooo", get_message(error)
   end
 
   def test_corrects_env_key_name
@@ -46,7 +46,7 @@ class KeyNameCheckTest < Test::Unit::TestCase
     ENV["BAR"] = "2"
     error = assert_raise(KeyError) { ENV.fetch("BAX") }
     assert_correction %("BAR"), error.corrections
-    assert_match %(Did you mean?  "BAR"), error.to_s
+    assert_match %(Did you mean?  "BAR"), get_message(error)
   ensure
     ENV.delete("FOO")
     ENV.delete("BAR")

data/test/spell_checking/test_method_name_check.rb

@@ -41,28 +41,28 @@ class MethodNameCheckTest < Test::Unit::TestCase
     error = assert_raise(NoMethodError){ @user.flrst_name }
 
     assert_correction :first_name, error.corrections
-    assert_match "Did you mean?  first_name",  error.to_s
+    assert_match "Did you mean?  first_name",  get_message(error)
   end
 
   def test_corrections_include_private_method
     error = assert_raise(NoMethodError){ @user.friend }
 
     assert_correction :friends, error.corrections
-    assert_match "Did you mean?  friends", error.to_s
+    assert_match "Did you mean?  friends", get_message(error)
   end
 
   def test_corrections_include_method_from_module
     error = assert_raise(NoMethodError){ @user.fr0m_module }
 
     assert_correction :from_module, error.corrections
-    assert_match "Did you mean?  from_module", error.to_s
+    assert_match "Did you mean?  from_module", get_message(error)
   end
 
   def test_corrections_include_class_method
     error = assert_raise(NoMethodError){ User.l0ad }
 
     assert_correction :load, error.corrections
-    assert_match "Did you mean?  load", error.to_s
+    assert_match "Did you mean?  load", get_message(error)
   end
 
   def test_private_methods_should_not_be_suggested
@@ -77,7 +77,7 @@ class MethodNameCheckTest < Test::Unit::TestCase
     error = assert_raise(NoMethodError){ @user.call_incorrect_private_method }
 
     assert_correction :raise, error.corrections
-    assert_match "Did you mean?  raise", error.to_s
+    assert_match "Did you mean?  raise", get_message(error)
   end
 
   def test_exclude_methods_on_nil
@@ -104,7 +104,7 @@ class MethodNameCheckTest < Test::Unit::TestCase
       end
     end
 
-    assert_equal 1, error.to_s.scan(/Did you mean/).count
+    assert_equal 1, get_message(error).scan(/Did you mean/).count
   end
 
   def test_does_not_append_suggestions_three_times
@@ -116,7 +116,7 @@ class MethodNameCheckTest < Test::Unit::TestCase
       end
     end
 
-    assert_equal 1, error.to_s.scan(/Did you mean/).count
+    assert_equal 1, get_message(error).scan(/Did you mean/).count
   end
 
   def test_suggests_corrections_on_nested_error
@@ -128,20 +128,20 @@ class MethodNameCheckTest < Test::Unit::TestCase
       end
     end
 
-    assert_equal 1, error.to_s.scan(/Did you mean/).count
+    assert_equal 1, get_message(error).scan(/Did you mean/).count
   end
 
   def test_suggests_yield
     error = assert_raise(NoMethodError) { yeild(1) }
 
     assert_correction :yield, error.corrections
-    assert_match "Did you mean?  yield", error.to_s
+    assert_match "Did you mean?  yield", get_message(error)
   end
 
   def test_does_not_suggest_yield
     error = assert_raise(NoMethodError) { 1.yeild }
 
     assert_correction [], error.corrections
-    assert_not_match(/Did you mean\? +yield/, error.to_s)
+    assert_not_match(/Did you mean\? +yield/, get_message(error))
   end if RUBY_ENGINE != "jruby"
 end

data/test/spell_checking/test_pattern_key_name_check.rb

@@ -0,0 +1,20 @@
+require_relative '../helper'
+
+return if !defined?(::NoMatchingPatternKeyError)
+
+class PatternKeyNameCheckTest < Test::Unit::TestCase
+  include DidYouMean::TestHelper
+
+  def test_corrects_hash_key_name_with_single_pattern_match
+    error = assert_raise(NoMatchingPatternKeyError) do
+      eval(<<~RUBY, binding, __FILE__, __LINE__)
+        hash = {foo: 1, bar: 2, baz: 3}
+        hash => {fooo:}
+        fooo = 1 # suppress "unused variable: fooo" warning
+      RUBY
+    end
+
+    assert_correction ":foo", error.corrections
+    assert_match "Did you mean?  :foo", get_message(error)
+  end
+end

data/test/spell_checking/test_require_path_check.rb

@@ -11,7 +11,7 @@ class RequirePathCheckTest < Test::Unit::TestCase
             end
 
     assert_correction 'ostruct', error.corrections
-    assert_match "Did you mean?  ostruct", error.to_s
+    assert_match "Did you mean?  ostruct", get_message(error)
   end
 
   def test_load_error_from_require_for_nested_files_has_suggestions
@@ -20,13 +20,13 @@ class RequirePathCheckTest < Test::Unit::TestCase
             end
 
     assert_correction 'net/http', error.corrections
-    assert_match "Did you mean?  net/http", error.to_s
+    assert_match "Did you mean?  net/http", get_message(error)
 
     error = assert_raise LoadError do
               require 'net-http'
             end
 
     assert_correction ['net/http', 'net/https'], error.corrections
-    assert_match "Did you mean?  net/http", error.to_s
+    assert_match "Did you mean?  net/http", get_message(error)
   end
 end

data/test/spell_checking/test_uncorrectable_name_check.rb

@@ -10,6 +10,6 @@ class UncorrectableNameCheckTest < Test::Unit::TestCase
   end
 
   def test_message
-    assert_equal "Other name error", @error.message
+    assert_not_match(/Did you mean\?/, @error.message)
   end
 end

data/test/spell_checking/test_variable_name_check.rb

@@ -39,7 +39,7 @@ class VariableNameCheckTest < Test::Unit::TestCase
     end
 
     assert_correction :first_name, error.corrections
-    assert_match "Did you mean?  first_name", error.to_s
+    assert_match "Did you mean?  first_name", get_message(error)
   end
 
   def test_corrections_include_method_from_module
@@ -48,7 +48,7 @@ class VariableNameCheckTest < Test::Unit::TestCase
     end
 
     assert_correction :from_module, error.corrections
-    assert_match "Did you mean?  from_module", error.to_s
+    assert_match "Did you mean?  from_module", get_message(error)
   end
 
   def test_corrections_include_local_variable_name
@@ -57,7 +57,7 @@ class VariableNameCheckTest < Test::Unit::TestCase
       error = (eprson rescue $!) # Do not use @assert_raise here as it changes a scope.
 
       assert_correction :person, error.corrections
-      assert_match "Did you mean?  person", error.to_s
+      assert_match "Did you mean?  person", get_message(error)
     end
   end
 
@@ -81,30 +81,30 @@ class VariableNameCheckTest < Test::Unit::TestCase
     end
 
     assert_correction :false, false_error.corrections
-    assert_match "Did you mean?  false", false_error.to_s
+    assert_match "Did you mean?  false", get_message(false_error)
 
     assert_correction :true, true_error.corrections
-    assert_match "Did you mean?  true", true_error.to_s
+    assert_match "Did you mean?  true", get_message(true_error)
 
     assert_correction :nil, nil_error.corrections
-    assert_match "Did you mean?  nil", nil_error.to_s
+    assert_match "Did you mean?  nil", get_message(nil_error)
 
     assert_correction :__FILE__, file_error.corrections
-    assert_match "Did you mean?  __FILE__", file_error.to_s
+    assert_match "Did you mean?  __FILE__", get_message(file_error)
   end
 
   def test_suggests_yield
     error = assert_raise(NameError) { yeild }
 
     assert_correction :yield, error.corrections
-    assert_match "Did you mean?  yield", error.to_s
+    assert_match "Did you mean?  yield", get_message(error)
   end
 
   def test_corrections_include_instance_variable_name
     error = assert_raise(NameError){ @user.to_s }
 
     assert_correction :@email_address, error.corrections
-    assert_match "Did you mean?  @email_address", error.to_s
+    assert_match "Did you mean?  @email_address", get_message(error)
   end
 
   def test_corrections_include_private_method
@@ -113,7 +113,7 @@ class VariableNameCheckTest < Test::Unit::TestCase
     end
 
     assert_correction :cia_codename, error.corrections
-    assert_match "Did you mean?  cia_codename",  error.to_s
+    assert_match "Did you mean?  cia_codename",  get_message(error)
   end
 
   @@does_exist = true
@@ -122,7 +122,7 @@ class VariableNameCheckTest < Test::Unit::TestCase
     error = assert_raise(NameError){ @@doesnt_exist }
 
     assert_correction :@@does_exist, error.corrections
-    assert_match "Did you mean?  @@does_exist", error.to_s
+    assert_match "Did you mean?  @@does_exist", get_message(error)
   end
 
   def test_struct_name_error
@@ -130,11 +130,23 @@ class VariableNameCheckTest < Test::Unit::TestCase
     error = assert_raise(NameError){ value[:doesnt_exist] }
 
     assert_correction [:does_exist, :does_exist=], error.corrections
-    assert_match "Did you mean?  does_exist", error.to_s
+    assert_match "Did you mean?  does_exist", get_message(error)
   end
 
   def test_exclude_typical_incorrect_suggestions
     error = assert_raise(NameError){ foo }
     assert_empty error.corrections
   end
+
+  def test_exclude_duplicates_with_same_name
+    error = assert_raise(NameError) do
+      eval(<<~RUBY, binding, __FILE__, __LINE__)
+        bar = 1
+        def bar;end
+        zar
+      RUBY
+    end
+
+    assert_correction [:bar], error.corrections
+  end
 end