did_you_mean 0.5.0 → 0.9.0

data/lib/did_you_mean/finders/similar_attribute_finder.rb

@@ -0,0 +1,26 @@
+module DidYouMean
+  class SimilarAttributeFinder
+    include BaseFinder
+    attr_reader :columns, :attribute_name
+
+    def initialize(exception)
+      @columns        = exception.frame_binding.eval("self.class").columns
+      @attribute_name = (/unknown attribute(: | ')(\w+)/ =~ exception.original_message) && $2
+    end
+
+    def words
+      columns.map(&:name)
+    end
+
+    alias target_word attribute_name
+
+    def format(column_name)
+      "%{column}: %{type}" % {
+        column: column_name,
+        type:   columns.detect{|c| c.name == column_name }.type
+      }
+    end
+  end
+
+  finders["ActiveRecord::UnknownAttributeError"] = SimilarAttributeFinder
+end

data/lib/did_you_mean/finders/similar_method_finder.rb

@@ -0,0 +1,42 @@
+module DidYouMean
+  class SimilarMethodFinder
+    include BaseFinder
+    attr_reader :method_name, :receiver
+
+    def initialize(exception)
+      @method_name, @receiver = exception.name, exception.args.first
+    end
+
+    def words
+      (receiver.methods + receiver.singleton_methods).uniq
+    end
+
+    alias target_word method_name
+
+    def format(word)
+      "#{separator}#{word}"
+    end
+
+    def class_method?
+      receiver.is_a? Class
+    end
+
+    def separator
+      class_method? ? "." : "#"
+    end
+  end
+
+  if defined?(RUBY_ENGINE)
+    finders["NoMethodError"] = SimilarMethodFinder
+
+    case RUBY_ENGINE
+    when 'ruby'
+      require 'did_you_mean/method_missing'
+    when 'jruby'
+      require 'did_you_mean/receiver_capturer'
+      org.yukinishijima.ReceiverCapturer.setup(JRuby.runtime)
+    else
+      finders.delete("NoMethodError")
+    end
+  end
+end

data/lib/did_you_mean/levenshtein.rb

@@ -0,0 +1,49 @@
+module DidYouMean
+  module Levenshtein # :nodoc:
+    # This code is based directly on the Text gem implementation
+    # Returns a value representing the "cost" of transforming str1 into str2
+    def distance(str1, str2)
+      n = str1.length
+      m = str2.length
+      return m if n.zero?
+      return n if m.zero?
+
+      d = (0..m).to_a
+      x = nil
+
+      str1.each_char.with_index(1) do |char1, i|
+        str2.each_char.with_index do |char2, j|
+          cost = (char1 == char2) ? 0 : 1
+          x = min3(
+            d[j+1] + 1, # insertion
+            i + 1,      # deletion
+            d[j] + cost # substitution
+          )
+          d[j] = i
+          i = x
+        end
+        d[m] = x
+      end
+
+      x
+    end
+    module_function :distance
+
+    private
+
+    # detects the minimum value out of three arguments. This method is
+    # faster than `[a, b, c].min` and puts less GC pressure.
+    # See https://github.com/yuki24/did_you_mean/pull/1 for a performance
+    # benchmark.
+    def min3(a, b, c)
+      if a < b && a < c
+        a
+      elsif b < c
+        b
+      else
+        c
+      end
+    end
+    module_function :min3
+  end
+end

data/lib/did_you_mean/test_helper.rb

@@ -0,0 +1,11 @@
+module DidYouMean
+  module TestHelper
+    def assert_suggestion(array, expected)
+      assert_equal [expected], array, "Expected #{array.inspect} to only include #{expected.inspect}"
+    end
+
+    def assert_nothing_raised
+      yield
+    end
+  end
+end

data/lib/did_you_mean/version.rb

@@ -1,3 +1,3 @@
 module DidYouMean
-  VERSION = "0.5.0"
+  VERSION = "0.9.0"
 end

data/lib/did_you_mean/word_collection.rb

@@ -0,0 +1,27 @@
+require 'did_you_mean/levenshtein'
+
+module DidYouMean
+  class WordCollection
+    include Enumerable
+    attr_reader :words
+
+    def initialize(words)
+      @words = words
+    end
+
+    def each(&block) words.each(&block); end
+
+    def similar_to(target_word)
+      target_word = target_word.to_s
+      threshold   = threshold(target_word)
+
+      select {|word| Levenshtein.distance(word.to_s, target_word) <= threshold }
+    end
+
+    private
+
+    def threshold(word)
+      (word.size * 0.3).ceil
+    end
+  end
+end

data/test/all_test.rb

@@ -1,3 +1,17 @@
+require_relative 'null_finder_test'
+require_relative 'name_error_extension_test'
 require_relative 'similar_name_finder_test'
-require_relative 'similar_method_finder_test'
-require_relative 'similar_attribute_finder_test'
+
+if defined?(RUBY_ENGINE) && %w(ruby jruby).include?(RUBY_ENGINE)
+  require_relative 'similar_method_finder_test'
+  require_relative 'no_method_error_extension_test'
+else
+  puts "didn't run the tests for NoMethodError extension."
+  puts "running tests for #{RUBY_ENGINE}." if defined?(RUBY_ENGINE)
+end
+
+if defined?(ActiveRecord)
+  require_relative 'similar_attribute_finder_test'
+end
+
+require_relative 'similar_class_finder_test'

data/test/name_error_extension_test.rb

@@ -0,0 +1,24 @@
+require_relative 'test_helper'
+
+class NameErrorExtensionTest < Minitest::Test
+  class TestFinder
+    def initialize(*); end
+    def did_you_mean?; "Y U SO SLOW?"; end
+  end
+
+  def setup
+    @old_finder = DidYouMean.finders["NameError"]
+    DidYouMean.finders["NameError"] = TestFinder
+
+    @error = assert_raises(NameError){ doesnt_exist }
+  end
+
+  def teardown
+    DidYouMean.finders["NameError"] = @old_finder
+  end
+
+  def test_message?
+    assert_match "Y U SO SLOW?", @error.to_s
+    assert_match "Y U SO SLOW?", @error.message
+  end
+end

data/test/no_method_error_extension_test.rb

@@ -0,0 +1,20 @@
+require_relative 'test_helper'
+
+class NoMethodErrorExtensionTest < Minitest::Test
+  def setup
+    @receiver = "receiver"
+    @error = assert_raises(NoMethodError) do
+      @receiver.doesnt_exist
+    end
+  end
+
+  def test_receiver
+    assert_same @receiver, @error.args.first
+  end
+
+  def test_extension_doesnt_break_ruby
+    assert_nothing_raised do
+      File.open('tmp/foo.txt', 'w'){|f| Array(Mail.new) }
+    end
+  end
+end

data/test/null_finder_test.rb

@@ -0,0 +1,19 @@
+require_relative 'test_helper'
+
+class NullFinderTest < Minitest::Test
+  class FirstNameError < NameError; end
+
+  def setup
+    @error = assert_raises(FirstNameError) do
+      raise FirstNameError, "Other name error"
+    end
+  end
+
+  def test_did_you_mean?
+    assert_nil @error.did_you_mean?
+  end
+
+  def test_message
+    refute_includes "Did you mean?", @error.message
+  end
+end

data/test/similar_attribute_finder_test.rb

@@ -7,15 +7,11 @@ class SimilarAttributeFinderTest < Minitest::Test
     end
   end
 
-  def test_similar_columns
-    assert @error.method_finder.similar_columns.include?("first_name")
+  def test_similar_words
+    assert_suggestion @error.finder.similar_words, "first_name"
   end
 
   def test_did_you_mean?
     assert_match "Did you mean? first_name: string", @error.did_you_mean?
   end
-
-  def test_message
-    assert_match @error.did_you_mean?, @error.message
-  end
 end

data/test/similar_class_finder_test.rb

@@ -0,0 +1,85 @@
+require_relative 'test_helper'
+
+class Project
+  def self.bo0k
+    Bo0k
+  end
+end
+
+class Book
+  class TableOfContents; end
+
+  def tableof_contents
+    TableofContents
+  end
+
+  class Page
+    def tableof_contents
+      TableofContents
+    end
+
+    def self.tableof_contents
+      TableofContents
+    end
+  end
+end
+
+class SimpleSimilarClassFinderTest < Minitest::Test
+  def setup
+    @error = assert_raises(NameError) { ::Bo0k }
+  end
+
+  def test_similar_words
+    assert_suggestion @error.finder.similar_words, "Book"
+  end
+end
+
+class SimilarClassFinderInsideClassTest < Minitest::Test
+  def setup
+    @error = assert_raises(NameError) { Project.bo0k }
+  end
+
+  def test_similar_words
+    assert_suggestion @error.finder.similar_words, "Book"
+  end
+end
+
+class SimilarClassFinderInsideNestedClassTest < Minitest::Test
+  def setup
+    @error = assert_raises(NameError) { Book::Page.tableof_contents }
+  end
+
+  def test_similar_words
+    assert_suggestion @error.finder.similar_words, "Book::TableOfContents"
+  end
+end
+
+class SimilarClassFinderForClassWithNamespaceTest < Minitest::Test
+  def setup
+    @error = assert_raises(NameError) { ::Book::TableofContents }
+  end
+
+  def test_similar_words
+    assert_suggestion @error.finder.similar_words, "Book::TableOfContents"
+  end
+end
+
+class SimilarClassFinderFromInstanceTest < Minitest::Test
+  def setup
+    @error = assert_raises(NameError) { ::Book.new.tableof_contents }
+  end
+
+  def test_similar_words
+    assert_suggestion @error.finder.similar_words, "Book::TableOfContents"
+  end
+end
+
+class SimilarClassFinderFromNestedInstanceTest < Minitest::Test
+  def setup
+    @error = assert_raises(NameError) { ::Book::Page.new.tableof_contents }
+  end
+
+  def test_similar_words
+    assert_suggestion @error.finder.similar_words, "Book::TableOfContents"
+  end
+end

data/test/similar_method_finder_test.rb

@@ -22,47 +22,28 @@ class SimilarMethodFinderTest < Minitest::Test
   def setup
     user = User.new.extend(UserModule)
 
-    @errors = {
-      from_instance_method: assert_raises(NoMethodError){ user.flrst_name },
-      from_private_method:  assert_raises(NoMethodError){ user.friend },
-      from_module_method:   assert_raises(NoMethodError){ user.fr0m_module },
-      from_class_method:    assert_raises(NoMethodError){ User.l0ad }
-    }
+    @error_from_instance_method = assert_raises(NoMethodError){ user.flrst_name }
+    @error_from_private_method  = assert_raises(NoMethodError){ user.friend }
+    @error_from_module_method   = assert_raises(NoMethodError){ user.fr0m_module }
+    @error_from_class_method    = assert_raises(NoMethodError){ User.l0ad }
   end
 
-  def test_unknown_attribute_error_with_did_you_mean
-    error = assert_raises(ActiveRecord::UnknownAttributeError) do
-      ::User.new(flrst_name: "wrong flrst name")
-    end
-
-    assert error.method_finder.similar_columns.include?("first_name")
-    assert_match "Did you mean? first_name", error.did_you_mean?
-    assert_match error.did_you_mean?, error.message
-  end
-
-  def test_similar_methods
-    assert @errors[:from_instance_method].method_finder.similar_methods.include?(:first_name)
-    assert  @errors[:from_private_method].method_finder.similar_methods.include?(:friends)
-    assert   @errors[:from_module_method].method_finder.similar_methods.include?(:from_module)
-    assert    @errors[:from_class_method].method_finder.similar_methods.include?(:load)
-  end
-
-  def test_similar_methods_for_long_method_name
-    error = assert_raises(NoMethodError){ User.new.dependents }
-    assert error.method_finder.similar_methods.include?(:descendants)
+  def test_similar_words
+    assert_suggestion @error_from_instance_method.finder.similar_words, :first_name
+    assert_suggestion @error_from_private_method.finder.similar_words,  :friends
+    assert_suggestion @error_from_module_method.finder.similar_words,   :from_module
+    assert_suggestion @error_from_class_method.finder.similar_words,    :load
   end
 
   def test_did_you_mean?
-    assert_match "Did you mean? #first_name",  @errors[:from_instance_method].did_you_mean?
-    assert_match "Did you mean? #friends",     @errors[:from_private_method].did_you_mean?
-    assert_match "Did you mean? #from_module", @errors[:from_module_method].did_you_mean?
-    assert_match "Did you mean? .load",        @errors[:from_class_method].did_you_mean?
+    assert_match "Did you mean? #first_name",  @error_from_instance_method.did_you_mean?
+    assert_match "Did you mean? #friends",     @error_from_private_method.did_you_mean?
+    assert_match "Did you mean? #from_module", @error_from_module_method.did_you_mean?
+    assert_match "Did you mean? .load",        @error_from_class_method.did_you_mean?
   end
 
-  def test_message
-    assert_match @errors[:from_instance_method].did_you_mean?, @errors[:from_instance_method].message
-    assert_match  @errors[:from_private_method].did_you_mean?,  @errors[:from_private_method].message
-    assert_match   @errors[:from_module_method].did_you_mean?,   @errors[:from_module_method].message
-    assert_match    @errors[:from_class_method].did_you_mean?,    @errors[:from_class_method].message
+  def test_similar_words_for_long_method_name
+    error = assert_raises(NoMethodError){ User.new.dependents }
+    assert_suggestion error.finder.similar_words, :descendants
   end
 end

data/test/similar_name_finder_test.rb

@@ -2,9 +2,16 @@ require_relative 'test_helper'
 
 class SimilarNameFinderTest < Minitest::Test
   class User
+    def initialize(options = {})
+      @email = options[:email]
+    end
+
     def call_flrst_name;  f1rst_name; end
     def call_fr0m_module; fr0m_module; end
     def first_name; end
+    def to_s
+      "#{@first_name} #{@last_name} <#{email}>"
+    end
   end
 
   module UserModule
@@ -14,41 +21,42 @@ class SimilarNameFinderTest < Minitest::Test
   def setup
     user = User.new.extend(UserModule)
 
-    @errors = {
-      from_instance_method: assert_raises(NameError){ user.call_flrst_name },
-      from_module_method:   assert_raises(NameError){ user.call_fr0m_module }
-    }
+    @error_from_instance_method = assert_raises(NameError){ user.call_flrst_name }
+    @error_from_module_method   = assert_raises(NameError){ user.call_fr0m_module }
+    @error_from_missing_at_sign = assert_raises(NameError){ user.to_s }
 
-    begin
+    # Use begin + rescue as #assert_raises changes a scope.
+    @error_from_local_variable  = begin
       userr
     rescue NameError => e
-      @instance_variable_error = e
+      e
     end
   end
 
-  def test_similar_methods
-    assert @errors[:from_instance_method].method_finder.similar_methods.include?(:first_name)
-    assert @errors[:from_module_method].method_finder.similar_methods.include?(:from_module)
+  def test_similar_words
+    assert_suggestion @error_from_instance_method.finder.similar_words, "first_name"
+    assert_suggestion @error_from_module_method.finder.similar_words,   "from_module"
+    assert_suggestion @error_from_local_variable.finder.similar_words,  "user"
+    assert_suggestion @error_from_missing_at_sign.finder.similar_words, "email"
   end
 
-  def test_similar_local_variables
-    assert @instance_variable_error.method_finder.similar_local_variables.include?(:user)
+  def test_similar_instance_methods
+    assert_suggestion @error_from_instance_method.finder.similar_methods, "first_name"
+    assert_suggestion @error_from_module_method.finder.similar_methods,   "from_module"
   end
 
-  def test_did_you_mean?
-    assert_match "Did you mean?", @errors[:from_instance_method].did_you_mean?
-    assert_match "instance methods: #first_name", @errors[:from_instance_method].did_you_mean?
-
-    assert_match "Did you mean?", @errors[:from_module_method].did_you_mean?
-    assert_match "instance methods: #from_module", @errors[:from_module_method].did_you_mean?
+  def test_similar_local_variables
+    assert_suggestion @error_from_local_variable.finder.similar_local_variables, "user"
+  end
 
-    assert_match "Did you mean?", @instance_variable_error.did_you_mean?
-    assert_match "local variables: user", @instance_variable_error.did_you_mean?
+  def test_similar_instance_variables
+    assert_suggestion @error_from_missing_at_sign.finder.similar_instance_variables, "email"
   end
 
-  def test_message
-    assert_match @errors[:from_instance_method].did_you_mean?, @errors[:from_instance_method].message
-    assert_match @errors[:from_module_method].did_you_mean?, @errors[:from_module_method].message
-    assert_match @instance_variable_error.did_you_mean?, @instance_variable_error.message
+  def test_did_you_mean?
+    assert_match "Did you mean? #first_name",  @error_from_instance_method.did_you_mean?
+    assert_match "Did you mean? #from_module", @error_from_module_method.did_you_mean?
+    assert_match "Did you mean? user",         @error_from_local_variable.did_you_mean?
+    assert_match "Did you mean? @email",       @error_from_missing_at_sign.did_you_mean?
   end
 end