did_you_mean 0.10.0 → 1.0.0.beta2

data/lib/did_you_mean/spell_checkers/method_name_checker.rb

@@ -0,0 +1,54 @@
+module DidYouMean
+  class MethodNameChecker
+    include SpellCheckable
+    attr_reader :method_name, :receiver
+
+    REPLS = {
+      "(irb)" => -> { Readline::HISTORY.to_a.last }
+    }
+
+    def initialize(exception)
+      @method_name = exception.name
+      @receiver    = exception.receiver
+      @binding     = exception.frame_binding
+      @location    = exception.backtrace_locations.first
+      @ivar_names  = VariableNameChecker.new(exception).ivar_names
+    end
+
+    def candidates
+      {
+        method_name        => method_names,
+        receiver_name.to_s => @ivar_names
+      }
+    end
+
+    def method_names
+      method_names = receiver.methods + receiver.singleton_methods
+      method_names += receiver.private_methods if receiver.equal?(@binding.receiver)
+      method_names.delete(method_name)
+      method_names.uniq!
+      method_names
+    end
+
+    def receiver_name
+      return unless @receiver.nil?
+
+      abs_path = @location.absolute_path
+      lineno   = @location.lineno
+
+      /@(\w+)*\.#{@method_name}/ =~ line(abs_path, lineno).to_s && $1
+    end
+
+    private
+
+    def line(abs_path, lineno)
+      if REPLS[abs_path]
+        REPLS[abs_path].call
+      elsif File.exist?(abs_path)
+        File.open(abs_path) do |file|
+          file.detect { file.lineno == lineno }
+        end
+      end
+    end
+  end
+end

data/lib/did_you_mean/{finders/name_error_finders.rb → spell_checkers/name_error_checkers.rb}

@@ -1,5 +1,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 NameErrorFinders
+  module NameErrorCheckers
     def self.included(*)
       raise "Do not include this module since it overrides Class.new method."
     end
@@ -7,15 +10,12 @@ module DidYouMean
     def self.new(exception)
       case exception.original_message
       when /uninitialized constant/
-        ClassFinder
+        ClassNameChecker
       when /undefined local variable or method/, /undefined method/, /uninitialized class variable/
-        NameFinder
+        VariableNameChecker
       else
-        NullFinder
+        NullChecker
       end.new(exception)
     end
   end
 end
-
-require 'did_you_mean/finders/name_error_finders/name_finder'
-require 'did_you_mean/finders/name_error_finders/class_finder'

data/lib/did_you_mean/{finders/name_error_finders/class_finder.rb → spell_checkers/name_error_checkers/class_name_checker.rb}

@@ -1,15 +1,15 @@
 require 'delegate'
 
 module DidYouMean
-  class ClassFinder
-    include BaseFinder
+  class ClassNameChecker
+    include SpellCheckable
     attr_reader :class_name, :original_message
 
     def initialize(exception)
       @class_name, @original_message = exception.name, exception.original_message
     end
 
-    def searches
+    def candidates
       {name_from_message => class_names}
     end
 
@@ -21,29 +21,11 @@ module DidYouMean
       end
     end
 
-    if RUBY_ENGINE == 'jruby'
-      # Always use the original error message to retrieve the user
-      # input since JRuby 1.7 behaves differently from MRI/Rubinius.
-      #
-      #   class Name; end
-      #   error = (Name::DoesNotExist rescue $!)
-      #
-      #   # on MRI/Rubinius
-      #   error.name #=> :DoesNotExist
-      #
-      #   # on JRuby <= 1.7
-      #   error.name #=> :'Name::DoesNotExist'
-      #
-      def name_from_message
-        /([A-Z]\w*$)/.match(original_message)[0]
-      end
-    else
-      def name_from_message
-        class_name || /([A-Z]\w*$)/.match(original_message)[0]
-      end
+    def name_from_message
+      class_name || /([A-Z]\w*$)/.match(original_message)[0]
     end
 
-    def suggestions
+    def corrections
       super.map(&:full_name)
     end
 
@@ -56,13 +38,13 @@ module DidYouMean
     private
 
     def scope_base
-      @scope_base ||= (/(([A-Z]\w*::)*)([A-Z]\w*)$/ =~ original_message ? $1 : "").split("::")
+      @scope_base ||= (/(([A-Z]\w*::)*)([A-Z]\w*)$/ =~ original_message ? $1 : EMPTY).split("::")
     end
 
     class ClassName < SimpleDelegator
       attr :namespace
 
-      def initialize(name, namespace = '')
+      def initialize(name, namespace = ''.freeze)
         super(name)
         @namespace = namespace
       end

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

@@ -0,0 +1,20 @@
+module DidYouMean
+  class VariableNameChecker
+    include SpellCheckable
+    attr_reader :name, :method_names, :lvar_names, :ivar_names, :cvar_names
+
+    def initialize(exception)
+      @name       = exception.name.to_s.tr(AT, EMPTY)
+      @lvar_names = exception.frame_binding.local_variables
+      receiver    = exception.frame_binding.receiver
+
+      @method_names = receiver.methods + receiver.private_methods
+      @cvar_names   = receiver.class.class_variables
+      @ivar_names   = receiver.instance_variables
+    end
+
+    def candidates
+      { name => (lvar_names + method_names + ivar_names + cvar_names) }
+    end
+  end
+end

data/lib/did_you_mean/spell_checkers/null_checker.rb

@@ -0,0 +1,6 @@
+module DidYouMean
+  class NullChecker
+    def initialize(*);  end
+    def corrections; [] end
+  end
+end

data/lib/did_you_mean/version.rb

@@ -1,3 +1,3 @@
 module DidYouMean
-  VERSION = "0.10.0"
+  VERSION = "1.0.0.beta2"
 end

data/test/core_ext/name_error_extension_test.rb

@@ -1,31 +1,30 @@
 require 'test_helper'
 
 class NameErrorExtensionTest < Minitest::Test
-  class TestFinder
+  SPELL_CHECKERS = DidYouMean::SPELL_CHECKERS
+
+  class TestSpellChecker
     def initialize(*); end
-    def suggestions; ["Y U SO SLOW?"]; end
+    def corrections; ["Y U SO SLOW?"]; end
   end
 
   def setup
-    @org = DidYouMean.finders[NAME_ERROR.to_s]
-    DidYouMean.finders[NAME_ERROR.to_s] = TestFinder
+    @org, SPELL_CHECKERS['NameError'] = SPELL_CHECKERS['NameError'], TestSpellChecker
 
-    @error = assert_raises(NAME_ERROR){ doesnt_exist }
+    @error = assert_raises(NameError){ doesnt_exist }
   end
 
   def teardown
-    DidYouMean.finders[NAME_ERROR.to_s] = @org
+    SPELL_CHECKERS['NameError'] = @org
   end
 
   def test_message_provides_original_message
-    skip if RUBY_ENGINE == 'rbx'
-
     assert_match "undefined local variable or method", @error.to_s
   end
 
   def test_message
-    assert_match "Did you mean? Y U SO SLOW?", @error.to_s
-    assert_match "Did you mean? Y U SO SLOW?", @error.message
+    assert_match "Did you mean?  Y U SO SLOW?", @error.to_s
+    assert_match "Did you mean?  Y U SO SLOW?", @error.message
   end
 
   def test_to_s_does_not_make_disruptive_changes_to_error_message
@@ -38,35 +37,33 @@ class NameErrorExtensionTest < Minitest::Test
 end
 
 class IgnoreCallersTest < Minitest::Test
+  SPELL_CHECKERS = DidYouMean::SPELL_CHECKERS
+
   class Boomer
     def initialize(*)
-      raise Exception, "finder was created when it shouldn't!"
+      raise Exception, "spell checker was created when it shouldn't!"
     end
   end
 
   def setup
-    @org = DidYouMean.finders[NAME_ERROR.to_s]
-    DidYouMean.finders[NAME_ERROR.to_s] = Boomer
+    @org, SPELL_CHECKERS['NameError'] = SPELL_CHECKERS['NameError'], Boomer
+    DidYouMean::IGNORED_CALLERS << /( |`)do_not_correct_typo'/
 
-    @error = assert_raises(NAME_ERROR){ doesnt_exist }
+    @error = assert_raises(NameError){ doesnt_exist }
   end
 
   def teardown
-    DidYouMean.finders[NAME_ERROR.to_s] = @org
-  end
-
-  def test_ignore_missing_name
-    assert_nothing_raised { missing_name }
+    SPELL_CHECKERS['NameError'] = @org
+    DidYouMean::IGNORED_CALLERS.clear
   end
 
-  def test_ignore_safe_constantize
-    assert_nothing_raised { safe_constantize }
+  def test_ignore
+    assert_nothing_raised { do_not_correct_typo }
   end
 
   private
 
-  def safe_constantize; @error.message end
-  def missing_name;     @error.message end
+  def do_not_correct_typo; @error.message end
 
   def assert_nothing_raised
     yield

data/test/correctable/class_name_test.rb

@@ -28,38 +28,38 @@ class Book
 end
 
 class ClassNameTest < Minitest::Test
-  def test_suggestions
+  def test_corrections
     error = assert_raises(NameError) { ::Bo0k }
-    assert_suggestion "Book", error.suggestions
+    assert_correction "Book", error.corrections
   end
 
-  def test_suggestions_include_case_specific_class_name
+  def test_corrections_include_case_specific_class_name
     error = assert_raises(NameError) { ::Acronym }
-    assert_suggestion "ACRONYM", error.suggestions
+    assert_correction "ACRONYM", error.corrections
   end
 
-  def test_suggestions_include_top_level_class_name
+  def test_corrections_include_top_level_class_name
     error = assert_raises(NameError) { Project.bo0k }
-    assert_suggestion "Book", error.suggestions
+    assert_correction "Book", error.corrections
   end
 
-  def test_names_in_suggestions_have_namespaces
+  def test_names_in_corrections_have_namespaces
     error = assert_raises(NameError) { ::Book::TableofContents }
-    assert_suggestion "Book::TableOfContents", error.suggestions
+    assert_correction "Book::TableOfContents", error.corrections
   end
 
-  def test_suggestions_searches_for_names_in_upper_level_scopes
+  def test_corrections_candidates_for_names_in_upper_level_scopes
     error = assert_raises(NameError) { Book::Page.tableof_contents }
-    assert_suggestion "Book::TableOfContents", error.suggestions
+    assert_correction "Book::TableOfContents", error.corrections
   end
 
-  def test_suggestions_should_work_from_within_instance_method
+  def test_corrections_should_work_from_within_instance_method
     error = assert_raises(NameError) { ::Book.new.tableof_contents }
-    assert_suggestion "Book::TableOfContents", error.suggestions
+    assert_correction "Book::TableOfContents", error.corrections
   end
 
-  def test_suggestions_should_work_from_within_instance_method_on_nested_class
+  def test_corrections_should_work_from_within_instance_method_on_nested_class
     error = assert_raises(NameError) { ::Book::Page.new.tableof_contents }
-    assert_suggestion "Book::TableOfContents", error.suggestions
+    assert_correction "Book::TableOfContents", error.corrections
   end
 end

data/test/correctable/method_name_test.rb

@@ -29,56 +29,56 @@ class MethodNameTest < Minitest::Test
     @user = User.new.extend(UserModule)
   end
 
-  def test_suggestions_include_instance_method
+  def test_corrections_include_instance_method
     error = assert_raises(NoMethodError){ @user.flrst_name }
 
-    assert_suggestion :first_name, error.suggestions
-    assert_match "Did you mean? first_name",  error.to_s
+    assert_correction :first_name, error.corrections
+    assert_match "Did you mean?  first_name",  error.to_s
   end
 
-  def test_suggestions_include_private_method
+  def test_corrections_include_private_method
     error = assert_raises(NoMethodError){ @user.friend }
 
-    assert_suggestion :friends, error.suggestions
-    assert_match "Did you mean? friends", error.to_s
+    assert_correction :friends, error.corrections
+    assert_match "Did you mean?  friends", error.to_s
   end
 
-  def test_suggestions_include_method_from_module
+  def test_corrections_include_method_from_module
     error = assert_raises(NoMethodError){ @user.fr0m_module }
 
-    assert_suggestion :from_module, error.suggestions
-    assert_match "Did you mean? from_module", error.to_s
+    assert_correction :from_module, error.corrections
+    assert_match "Did you mean?  from_module", error.to_s
   end
 
-  def test_suggestions_include_class_method
+  def test_corrections_include_class_method
     error = assert_raises(NoMethodError){ User.l0ad }
 
-    assert_suggestion :load, error.suggestions
-    assert_match "Did you mean? load", error.to_s
+    assert_correction :load, error.corrections
+    assert_match "Did you mean?  load", error.to_s
   end
 
   def test_private_methods_should_not_be_suggested
     error = assert_raises(NoMethodError){ User.new.the_protected_method }
-    refute_includes error.suggestions, :the_protected_method
+    refute_includes error.corrections, :the_protected_method
 
     error = assert_raises(NoMethodError){ User.new.the_private_method }
-    refute_includes error.suggestions, :the_private_method
+    refute_includes error.corrections, :the_private_method
   end
 
-  def test_suggestions_when_private_method_is_called_with_args
+  def test_corrections_when_private_method_is_called_with_args
     error = assert_raises(NoMethodError){ @user.call_incorrect_private_method }
 
-    assert_suggestion :raise, error.suggestions
-    assert_match "Did you mean? raise", error.to_s
+    assert_correction :raise, error.corrections
+    assert_match "Did you mean?  raise", error.to_s
   end
 
   def test_corrects_incorrect_ivar_name
-    skip if RUBY_ENGINE == 'rbx'
-
     @number = 1
+    @nubmer = nil
     error = assert_raises(NoMethodError) { @nubmer.zero? }
+    remove_instance_variable :@nubmer
 
-    assert_suggestion :@number, error.suggestions
-    assert_match "Did you mean? @number", error.to_s
+    assert_correction :@number, error.corrections
+    assert_match "Did you mean?  @number", error.to_s
   end
 end

data/test/correctable/variable_name_test.rb

@@ -4,6 +4,8 @@ class VariableNameTest < Minitest::Test
   class User
     def initialize
       @email_address = 'email_address@address.net'
+      @first_name    = nil
+      @last_name     = nil
     end
 
     def first_name; end
@@ -24,56 +26,59 @@ class VariableNameTest < Minitest::Test
     @user = User.new.extend(UserModule)
   end
 
-  def test_suggestions_include_instance_method
-    error = assert_raises(NAME_ERROR) do
+  def test_corrections_include_instance_method
+    error = assert_raises(NameError) do
       @user.instance_eval { flrst_name }
     end
 
-    assert_suggestion :first_name, error.suggestions
-    assert_match "Did you mean? first_name", error.to_s
+    @user.instance_eval do
+      remove_instance_variable :@first_name
+      remove_instance_variable :@last_name
+    end
+
+    assert_correction :first_name, error.corrections
+    assert_match "Did you mean?  first_name", error.to_s
   end
 
-  def test_suggestions_include_method_from_module
-    error = assert_raises(NAME_ERROR) do
+  def test_corrections_include_method_from_module
+    error = assert_raises(NameError) do
       @user.instance_eval { fr0m_module }
     end
 
-    assert_suggestion :from_module, error.suggestions
-    assert_match "Did you mean? from_module", error.to_s
+    assert_correction :from_module, error.corrections
+    assert_match "Did you mean?  from_module", error.to_s
   end
 
-  def test_suggestions_include_local_variable_name
-    person  = nil
+  def test_corrections_include_local_variable_name
+    person = person = nil
     error = (eprson rescue $!) # Do not use @assert_raises here as it changes a scope.
 
-    assert_suggestion :person, error.suggestions
-    assert_match "Did you mean? person", error.to_s
+    assert_correction :person, error.corrections
+    assert_match "Did you mean?  person", error.to_s
   end
 
-  def test_suggestions_include_instance_variable_name
-    error = assert_raises(NAME_ERROR){ @user.to_s }
+  def test_corrections_include_instance_variable_name
+    error = assert_raises(NameError){ @user.to_s }
 
-    assert_suggestion :@email_address, error.suggestions
-    assert_match "Did you mean? @email_address", error.to_s
+    assert_correction :@email_address, error.corrections
+    assert_match "Did you mean?  @email_address", error.to_s
   end
 
-  def test_suggestions_include_private_method
-    error = assert_raises(NAME_ERROR) do
+  def test_corrections_include_private_method
+    error = assert_raises(NameError) do
       @user.instance_eval { cia_code_name }
     end
 
-    assert_suggestion :cia_codename,  error.suggestions
-    assert_match "Did you mean? cia_codename",  error.to_s
+    assert_correction :cia_codename, error.corrections
+    assert_match "Did you mean?  cia_codename",  error.to_s
   end
 
   @@does_exist = true
 
-  def test_suggestions_include_class_variable_name
-    skip if RUBY_ENGINE == 'rbx'
-
+  def test_corrections_include_class_variable_name
     error = assert_raises(NameError){ @@doesnt_exist }
 
-    assert_suggestion :@@does_exist, error.suggestions
-    assert_match "Did you mean? @@does_exist", error.to_s
+    assert_correction :@@does_exist, error.corrections
+    assert_match "Did you mean?  @@does_exist", error.to_s
   end
 end