did_you_mean 1.1.0 → 1.3.0

data/lib/did_you_mean/formatters/verbose_formatter.rb

@@ -0,0 +1,49 @@
+# frozen-string-literal: true
+
+module DidYouMean
+  # The +DidYouMean::VerboseFormatter+ uses extra empty lines to make the
+  # suggestion stand out more in the error message.
+  #
+  # In order to activate the verbose formatter,
+  #
+  # @example
+  #
+  #   OBject
+  #   # => NameError: uninitialized constant OBject
+  #   #    Did you mean?  Object
+  #
+  #   require 'did_you_mean/verbose'
+  #
+  #   OBject
+  #   # => NameError: uninitialized constant OBject
+  #   #
+  #   #        Did you mean? Object
+  #   #
+  #
+  class VerboseFormatter
+
+    # Returns a human readable string that contains +corrections+. This
+    # formatter is designed to be less verbose to not take too much screen
+    # space while being helpful enough to the user.
+    #
+    # @example
+    #
+    #   formatter = DidYouMean::PlainFormatter.new
+    #
+    #   puts formatter.message_for(["methods", "method"])
+    #
+    #
+    #       Did you mean? methods
+    #                     method
+    #
+    #   # => nil
+    #
+    def message_for(corrections)
+      return "" if corrections.empty?
+
+      output = "\n\n    Did you mean? ".dup
+      output << corrections.join("\n                  ")
+      output << "\n "
+    end
+  end
+end

data/lib/did_you_mean/spell_checkers/key_error_checker.rb

@@ -0,0 +1,14 @@
+require "did_you_mean/spell_checker"
+
+module DidYouMean
+  class KeyErrorChecker
+    def initialize(key_error)
+      @key = key_error.key
+      @keys = key_error.receiver.keys
+    end
+
+    def corrections
+      @corrections ||= SpellChecker.new(dictionary: @keys).correct(@key).map(&:inspect)
+    end
+  end
+end

data/lib/did_you_mean/spell_checkers/method_name_checker.rb

@@ -1,3 +1,5 @@
+require "did_you_mean/spell_checker"
+
 module DidYouMean
   class MethodNameChecker
     attr_reader :method_name, :receiver
@@ -5,6 +7,35 @@ module DidYouMean
     NAMES_TO_EXCLUDE = { NilClass => nil.methods }
     NAMES_TO_EXCLUDE.default = []
 
+    # +MethodNameChecker::RB_RESERVED_WORDS+ is the list of reserved words in
+    # Ruby that take an argument. Unlike
+    # +VariableNameChecker::RB_RESERVED_WORDS+, those reserved words reqquires
+    # an argument, and a +NoMethodError+ is raised due to the presence of the
+    # argument.
+    #
+    # The +MethodNameChecker+ will use this list to suggest a reversed word if
+    # a +NoMethodError+ is raised and found closest matches.
+    #
+    # Also see +VariableNameChecker::RB_RESERVED_WORDS+.
+    RB_RESERVED_WORDS = %i(
+      alias
+      case
+      def
+      defined?
+      elsif
+      end
+      ensure
+      for
+      rescue
+      super
+      undef
+      unless
+      until
+      when
+      while
+      yield
+    )
+
     def initialize(exception)
       @method_name  = exception.name
       @receiver     = exception.receiver
@@ -12,7 +43,7 @@ module DidYouMean
     end
 
     def corrections
-      @corrections ||= SpellChecker.new(dictionary: method_names).correct(method_name) - NAMES_TO_EXCLUDE[@receiver.class]
+      @corrections ||= SpellChecker.new(dictionary: RB_RESERVED_WORDS + method_names).correct(method_name) - NAMES_TO_EXCLUDE[@receiver.class]
     end
 
     def method_names

data/lib/did_you_mean/spell_checkers/name_error_checkers/class_name_checker.rb

@@ -1,16 +1,20 @@
 # frozen-string-literal: true
 require 'delegate'
+require "did_you_mean/spell_checker"
 
 module DidYouMean
   class ClassNameChecker
     attr_reader :class_name
 
     def initialize(exception)
-      @class_name, @receiver = exception.name, exception.receiver
+      @class_name, @receiver, @original_message = exception.name, exception.receiver, exception.original_message
     end
 
     def corrections
-      @corrections ||= SpellChecker.new(dictionary: class_names).correct(class_name).map(&:full_name)
+      @corrections ||= SpellChecker.new(dictionary: class_names)
+                         .correct(class_name)
+                         .map(&:full_name)
+                         .reject {|qualified_name| @original_message.include?(qualified_name) }
     end
 
     def class_names

data/lib/did_you_mean/spell_checkers/name_error_checkers/variable_name_checker.rb

@@ -1,12 +1,67 @@
 # frozen-string-literal: true
 
+require "did_you_mean/spell_checker"
+
 module DidYouMean
   class VariableNameChecker
     attr_reader :name, :method_names, :lvar_names, :ivar_names, :cvar_names
 
-    NAMES_TO_EXCLUDE = { 'foo' => [:fork] }
+    NAMES_TO_EXCLUDE = { 'foo' => [:fork, :for] }
     NAMES_TO_EXCLUDE.default = []
 
+    # +VariableNameChecker::RB_RESERVED_WORDS+ is the list of all reserved
+    # words in Ruby. They could be declared like methods are, and a typo would
+    # cause Ruby to raise a +NameError+ because of the way they are declared.
+    #
+    # The +:VariableNameChecker+ will use this list to suggest a reversed word
+    # if a +NameError+ is raised and found closest matches, excluding:
+    #
+    #   * +do+
+    #   * +if+
+    #   * +in+
+    #   * +or+
+    #
+    # Also see +MethodNameChecker::RB_RESERVED_WORDS+.
+    RB_RESERVED_WORDS = %i(
+      BEGIN
+      END
+      alias
+      and
+      begin
+      break
+      case
+      class
+      def
+      defined?
+      else
+      elsif
+      end
+      ensure
+      false
+      for
+      module
+      next
+      nil
+      not
+      redo
+      rescue
+      retry
+      return
+      self
+      super
+      then
+      true
+      undef
+      unless
+      until
+      when
+      while
+      yield
+      __LINE__
+      __FILE__
+      __ENCODING__
+    )
+
     def initialize(exception)
       @name       = exception.name.to_s.tr("@", "")
       @lvar_names = exception.respond_to?(:local_variables) ? exception.local_variables : []
@@ -20,7 +75,7 @@ module DidYouMean
 
     def corrections
       @corrections ||= SpellChecker
-                     .new(dictionary: (lvar_names + method_names + ivar_names + cvar_names))
+                     .new(dictionary: (RB_RESERVED_WORDS + lvar_names + method_names + ivar_names + cvar_names))
                      .correct(name) - NAMES_TO_EXCLUDE[@name]
     end
   end

data/lib/did_you_mean/spell_checkers/name_error_checkers.rb

@@ -2,12 +2,8 @@ require 'did_you_mean/spell_checkers/name_error_checkers/class_name_checker'
 require 'did_you_mean/spell_checkers/name_error_checkers/variable_name_checker'
 
 module DidYouMean
-  module NameErrorCheckers
-    def self.included(*)
-      raise "Do not include this module since it overrides Class.new method."
-    end
-
-    def self.new(exception)
+  class << (NameErrorCheckers = Object.new)
+    def new(exception)
       case exception.original_message
       when /uninitialized constant/
         ClassNameChecker

data/lib/did_you_mean/verbose.rb

@@ -0,0 +1,4 @@
+require 'did_you_mean'
+require 'did_you_mean/formatters/verbose_formatter'
+
+DidYouMean.formatter = DidYouMean::VerboseFormatter.new

data/lib/did_you_mean/version.rb

@@ -1,3 +1,3 @@
 module DidYouMean
-  VERSION = "1.1.0"
+  VERSION = "1.3.0"
 end

data/lib/did_you_mean.rb

@@ -4,16 +4,106 @@ require "did_you_mean/core_ext/name_error"
 require "did_you_mean/spell_checker"
 require 'did_you_mean/spell_checkers/name_error_checkers'
 require 'did_you_mean/spell_checkers/method_name_checker'
+require 'did_you_mean/spell_checkers/key_error_checker'
 require 'did_you_mean/spell_checkers/null_checker'
 
-require "did_you_mean/formatter"
+require "did_you_mean/formatters/plain_formatter"
 
+# The +DidYouMean+ gem adds functionality to suggest possible method/class
+# names upon errors such as +NameError+ and +NoMethodError+. In Ruby 2.3 or
+# later, it is automatically activated during startup.
+#
+# @example
+#
+#   methosd
+#   # => NameError: undefined local variable or method `methosd' for main:Object
+#   #   Did you mean?  methods
+#   #                  method
+#
+#   OBject
+#   # => NameError: uninitialized constant OBject
+#   #    Did you mean?  Object
+#
+#   @full_name = "Yuki Nishijima"
+#   first_name, last_name = full_name.split(" ")
+#   # => NameError: undefined local variable or method `full_name' for main:Object
+#   #    Did you mean?  @full_name
+#
+#   @@full_name = "Yuki Nishijima"
+#   @@full_anme
+#   # => NameError: uninitialized class variable @@full_anme in Object
+#   #    Did you mean?  @@full_name
+#
+#   full_name = "Yuki Nishijima"
+#   full_name.starts_with?("Y")
+#   # => NoMethodError: undefined method `starts_with?' for "Yuki Nishijima":String
+#   #    Did you mean?  start_with?
+#
+#   hash = {foo: 1, bar: 2, baz: 3}
+#   hash.fetch(:fooo)
+#   # => KeyError: key not found: :fooo
+#   #    Did you mean?  :foo
+#
+#
+# == Disabling +did_you_mean+
+#
+# Occasionally, you may want to disable the +did_you_mean+ gem for e.g.
+# debugging issues in the error object itself. You can disable it entirely by
+# specifying +--disable-did_you_mean+ option to the +ruby+ command:
+#
+#   $ ruby --disable-did_you_mean -e "1.zeor?"
+#   -e:1:in `<main>': undefined method `zeor?' for 1:Integer (NameError)
+#
+# When you do not have direct access to the +ruby+ command (e.g.
+# +rails console+, +irb+), you could applyoptions using the +RUBYOPT+
+# environment variable:
+#
+#   $ RUBYOPT='--disable-did_you_mean' irb
+#   irb:0> 1.zeor?
+#   # => NoMethodError (undefined method `zeor?' for 1:Integer)
+#
+#
+# == Getting the original error message
+#
+# Sometimes, you do not want to disable the gem entirely, but need to get the
+# original error message without suggestions (e.g. testing). In this case, you
+# could use the +#original_message+ method on the error object:
+#
+#   no_method_error = begin
+#                       1.zeor?
+#                     rescue NoMethodError => error
+#                       error
+#                     end
+#
+#   no_method_error.message
+#   # => NoMethodError (undefined method `zeor?' for 1:Integer)
+#   #    Did you mean?  zero?
+#
+#   no_method_error.original_message
+#   # => NoMethodError (undefined method `zeor?' for 1:Integer)
+#
 module DidYouMean
-  IGNORED_CALLERS = []
-
+  # Map of error types and spell checker objects.
   SPELL_CHECKERS = Hash.new(NullChecker)
+
   SPELL_CHECKERS.merge!({
     "NameError"     => NameErrorCheckers,
-    "NoMethodError" => MethodNameChecker
+    "NoMethodError" => MethodNameChecker,
+    "KeyError"      => KeyErrorChecker
   })
+
+  NameError.prepend DidYouMean::Correctable
+  KeyError.prepend DidYouMean::Correctable
+
+  # Returns the currenctly set formatter. By default, it is set to +DidYouMean::Formatter+.
+  def self.formatter
+    @@formatter
+  end
+
+  # Updates the primary formatter used to format the suggestions.
+  def self.formatter=(formatter)
+    @@formatter = formatter
+  end
+
+  self.formatter = PlainFormatter.new
 end

data/test/core_ext/name_error_extension_test.rb

@@ -20,7 +20,7 @@ class NameErrorExtensionTest < Minitest::Test
 
   def test_message
     message = <<~MESSAGE.chomp
-      undefined local variable or method `doesnt_exist' for #{method(:to_s).super_method.call}
+      undefined local variable or method `doesnt_exist' for #{to_s}
       Did you mean?  does_exist
     MESSAGE
 
@@ -36,38 +36,16 @@ class NameErrorExtensionTest < Minitest::Test
     error.to_s
     assert_equal 1, error.to_s.scan("Did you mean?").count
   end
-end
-
-class IgnoreCallersTest < Minitest::Test
-  SPELL_CHECKERS = DidYouMean::SPELL_CHECKERS
-
-  class Boomer
-    def initialize(*)
-      raise Exception, "spell checker was created when it shouldn't!"
-    end
-  end
-
-  def setup
-    @org, SPELL_CHECKERS['NameError'] = SPELL_CHECKERS['NameError'], Boomer
-    DidYouMean::IGNORED_CALLERS << /( |`)do_not_correct_typo'/
-
-    @error = assert_raises(NameError){ doesnt_exist }
-  end
-
-  def teardown
-    SPELL_CHECKERS['NameError'] = @org
-    DidYouMean::IGNORED_CALLERS.clear
-  end
-
-  def test_ignore
-    assert_nothing_raised { do_not_correct_typo }
-  end
 
-  private
+  def test_correctable_error_objects_are_dumpable
+   error = begin
+             File.open('./tmp/.keep').sizee
+           rescue NoMethodError => e
+             e
+           end
 
-  def do_not_correct_typo; @error.message end
+   error.to_s
 
-  def assert_nothing_raised
-    yield
+   assert_equal "undefined method `sizee' for #<File:./tmp/.keep>", Marshal.load(Marshal.dump(error)).original_message
   end
 end

data/test/edit_distance/jaro_winkler_test.rb

@@ -1,6 +1,11 @@
-# -*- coding: utf-8 -*-
 require 'test_helper'
 
+# These tests were originally written by Jian Weihang (簡煒航) as part of his work
+# on the jaro_winkler gem. The original code could be found here:
+#   https://github.com/tonytonyjan/jaro_winkler/blob/9bd12421/spec/jaro_winkler_spec.rb
+#
+# Copyright (c) 2014 Jian Weihang
+
 class JaroWinklerTest < Minitest::Test
   def test_jaro_winkler_distance
     assert_distance 0.9667, 'henka',      'henkan'

data/test/fixtures/book.rb

@@ -0,0 +1,4 @@
+class Book
+  class Cover
+  end
+end

data/test/spell_checking/{class_name_test.rb → class_name_check_test.rb}

@@ -27,7 +27,7 @@ class Book
   end
 end
 
-class ClassNameTest < Minitest::Test
+class ClassNameCheckTest < Minitest::Test
   def test_corrections
     error = assert_raises(NameError) { ::Bo0k }
     assert_correction "Book", error.corrections
@@ -62,4 +62,16 @@ class ClassNameTest < Minitest::Test
     error = assert_raises(NameError) { ::Book::Page.new.tableof_contents }
     assert_correction "Book::TableOfContents", error.corrections
   end
+
+  def test_does_not_suggest_user_input
+    error = assert_raises(NameError) { ::Book::Cover }
+
+    # This is a weird require, but in a multi-threaded condition, a constant may
+    # be loaded between when a NameError occurred and when the spell checker
+    # attemps to find a possible suggestion. The manual require here simulates
+    # a race condition a single test.
+    require_relative '../fixtures/book'
+
+    assert_empty error.corrections
+  end
 end

data/test/spell_checking/key_name_check_test.rb

@@ -0,0 +1,44 @@
+require "test_helper"
+
+class KeyNameCheckTest < Minitest::Test
+  def test_corrects_hash_key_name_with_fetch
+    hash = { "foo" => 1, bar: 2 }
+
+    error = assert_raises(KeyError) { hash.fetch(:bax) }
+    assert_correction ":bar", error.corrections
+    assert_match "Did you mean?  :bar", error.to_s
+
+    error = assert_raises(KeyError) { hash.fetch("fooo") }
+    assert_correction %("foo"), error.corrections
+    assert_match %(Did you mean?  "foo"), error.to_s
+  end
+
+  def test_corrects_hash_key_name_with_fetch_values
+    hash = { "foo" => 1, bar: 2 }
+
+    error = assert_raises(KeyError) { hash.fetch_values("foo", :bar, :bax) }
+    assert_correction ":bar", error.corrections
+    assert_match "Did you mean?  :bar", error.to_s
+
+    error = assert_raises(KeyError) { hash.fetch_values("foo", :bar, "fooo") }
+    assert_correction %("foo"), error.corrections
+    assert_match %(Did you mean?  "foo"), error.to_s
+  end
+
+  def test_corrects_sprintf_key_name
+    error = assert_raises(KeyError) { sprintf("%<foo>d", {fooo: 1}) }
+    assert_correction ":fooo", error.corrections
+    assert_match "Did you mean?  :fooo", error.to_s
+  end
+
+  def test_corrects_env_key_name
+    ENV["FOO"] = "1"
+    ENV["BAR"] = "2"
+    error = assert_raises(KeyError) { ENV.fetch("BAX") }
+    assert_correction %("BAR"), error.corrections
+    assert_match %(Did you mean?  "BAR"), error.to_s
+  ensure
+    ENV.delete("FOO")
+    ENV.delete("BAR")
+  end
+end

data/test/spell_checking/{method_name_test.rb → method_name_check_test.rb}

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class MethodNameTest < Minitest::Test
+class MethodNameCheckTest < Minitest::Test
   class User
     def friends; end
     def first_name; end
@@ -9,6 +9,12 @@ class MethodNameTest < Minitest::Test
       raiae NoMethodError
     end
 
+    def raise_no_method_error
+      self.firstname
+    rescue NoMethodError => e
+      raise e, e.message, e.backtrace
+    end
+
     protected
     def the_protected_method; end
 
@@ -86,4 +92,35 @@ class MethodNameTest < Minitest::Test
   ensure
     NilClass.class_eval { undef empty? }
   end
+
+  def test_does_not_append_suggestions_twice
+    error = assert_raises NoMethodError do
+      begin
+        @user.firstname
+      rescue NoMethodError => e
+        raise e, e.message, e.backtrace
+      end
+    end
+
+    assert_equal 1, error.to_s.scan(/Did you mean/).count
+  end
+
+  def test_does_not_append_suggestions_three_times
+    error = assert_raises NoMethodError do
+      begin
+        @user.raise_no_method_error
+      rescue NoMethodError => e
+        raise e, e.message, e.backtrace
+      end
+    end
+
+    assert_equal 1, error.to_s.scan(/Did you mean/).count
+  end
+
+  def test_suggests_yield
+    error = assert_raises(NoMethodError) { yeild(1) }
+
+    assert_correction :yield, error.corrections
+    assert_match "Did you mean?  yield", error.to_s
+  end
 end

data/test/spell_checking/{uncorrectable_name_test.rb → uncorrectable_name_check_test.rb}

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class UncorrectableNameTest < Minitest::Test
+class UncorrectableNameCheckTest < Minitest::Test
   class FirstNameError < NameError; end
 
   def setup

data/test/spell_checking/{variable_name_test.rb → variable_name_check_test.rb}

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class VariableNameTest < Minitest::Test
+class VariableNameCheckTest < Minitest::Test
   class User
     def initialize
       @email_address = 'email_address@address.net'
@@ -57,6 +57,45 @@ class VariableNameTest < Minitest::Test
     assert_match "Did you mean?  person", error.to_s
   end
 
+  def test_corrections_include_ruby_predefined_objects
+    some_var = nil
+
+    false_error = assert_raises(NameError) do
+      some_var = fals
+    end
+
+    true_error = assert_raises(NameError) do
+      some_var = treu
+    end
+
+    nil_error = assert_raises(NameError) do
+      some_var = nul
+    end
+
+    file_error = assert_raises(NameError) do
+      __FIEL__
+    end
+
+    assert_correction :false, false_error.corrections
+    assert_match "Did you mean?  false", false_error.to_s
+
+    assert_correction :true, true_error.corrections
+    assert_match "Did you mean?  true", true_error.to_s
+
+    assert_correction :nil, nil_error.corrections
+    assert_match "Did you mean?  nil", nil_error.to_s
+
+    assert_correction :__FILE__, file_error.corrections
+    assert_match "Did you mean?  __FILE__", file_error.to_s
+  end
+
+  def test_suggests_yield
+    error = assert_raises(NameError) { yeild }
+
+    assert_correction :yield, error.corrections
+    assert_match "Did you mean?  yield", error.to_s
+  end
+
   def test_corrections_include_instance_variable_name
     error = assert_raises(NameError){ @user.to_s }
 

data/test/verbose_formatter_test.rb

@@ -2,13 +2,19 @@ require 'test_helper'
 
 class VerboseFormatterTest < Minitest::Test
   def setup
+    require 'did_you_mean/verbose'
+
     does_exist = does_exist = nil
     @error = assert_raises(NameError){ doesnt_exist }
   end
 
+  def teardown
+    DidYouMean.formatter = DidYouMean::PlainFormatter.new
+  end
+
   def test_message
     assert_equal <<~MESSAGE.chomp, @error.message
-      undefined local variable or method `doesnt_exist' for #{method(:to_s).super_method.call}
+      undefined local variable or method `doesnt_exist' for #{to_s}
 
           Did you mean? does_exist