did_you_mean 0.9.10-java → 0.10.0-java

data/ext/did_you_mean/extconf.rb

@@ -1,2 +1,2 @@
 require 'mkmf'
-create_makefile 'did_you_mean/method_missing'
+create_makefile 'did_you_mean/method_receiver'

data/ext/did_you_mean/{method_missing.c → method_receiver.c}

@@ -11,7 +11,7 @@ name_err_receiver(VALUE self)
 }
 
 void
-Init_method_missing()
+Init_method_receiver()
 {
   VALUE err_mesg = rb_funcall(rb_cNameErrorMesg, '!', 3, Qnil, Qnil, Qnil);
   type = RTYPEDDATA(err_mesg)->type;

data/lib/did_you_mean.rb

@@ -4,14 +4,33 @@ require "did_you_mean/version"
 require "did_you_mean/core_ext/name_error"
 require "did_you_mean/core_ext/no_method_error"
 require "did_you_mean/finders"
+require "did_you_mean/formatter"
 
 module DidYouMean
-  Interception.listen(->(exception, binding) {
+  Interception.listen do |exception, binding|
     # On IRB/pry console, this event is called twice. In the second event,
     # we get IRB/pry binding. So it shouldn't override @frame_binding if
     # it's already defined.
-    if exception.is_a?(NameError) && !exception.instance_variable_defined?(:@frame_binding)
+    if DidYouMean.finders.include?(exception.class.to_s) && !exception.instance_variable_defined?(:@frame_binding)
       exception.instance_variable_set(:@frame_binding, binding)
     end
-  })
+  end
+
+  def self.finders
+    @@finders ||= Hash.new(NullFinder)
+  end
+
+  finders.merge!("NameError" => NameErrorFinders)
+
+  case RUBY_ENGINE
+  when 'ruby', 'jruby'
+    finders["NoMethodError"] = MethodFinder
+  when 'rbx'
+    finders["NoMethodError"] =
+      if (___ rescue $!).class.to_s == "NameError" # For rbx > 2.5.0
+        MethodFinder
+      else
+        MethodFinder::RubiniusSupport              # For rbx < 2.5.0
+      end
+  end
 end

data/lib/did_you_mean/core_ext/name_error.rb

@@ -1,30 +1,38 @@
-class NameError
-  attr_reader :frame_binding
+module DidYouMean
+  module Correctable
+    attr_reader :frame_binding
 
-  IGNORED_CALLERS = [
-    /( |`)missing_name'/,
-    /( |`)safe_constantize'/
-  ].freeze
-  private_constant :IGNORED_CALLERS
+    IGNORED_CALLERS = [
+      /( |`)missing_name'/,
+      /( |`)safe_constantize'/
+    ].freeze
+    private_constant :IGNORED_CALLERS
 
-  def to_s_with_did_you_mean
-    msg = original_message.dup
-    bt  = caller.first(6)
+    def self.included(klass)
+      klass.class_eval do
+        __to_s__ = klass.instance_method(:to_s)
+        define_method(:original_message){ __to_s__.bind(self).call }
 
-    msg << did_you_mean?.to_s if IGNORED_CALLERS.all? {|ignored| bt.grep(ignored).empty? }
-    msg
-  rescue
-    original_message
-  end
+        def to_s
+          msg = original_message.dup
+          bt  = caller.first(6)
 
-  alias original_message to_s
-  alias             to_s to_s_with_did_you_mean
+          msg << Formatter.new(suggestions).to_s if IGNORED_CALLERS.all? {|ignored| bt.grep(ignored).empty? }
+          msg
+        rescue
+          original_message
+        end
+      end
+    end
 
-  def did_you_mean?
-    finder.did_you_mean?
-  end
+    def suggestions
+      finder.suggestions
+    end
 
-  def finder
-    @finder ||= DidYouMean.finders[self.class.to_s].new(self)
+    def finder
+      @finder ||= DidYouMean.finders[self.class.to_s].new(self)
+    end
   end
 end
+
+NameError.send(:include, DidYouMean::Correctable)

data/lib/did_you_mean/core_ext/no_method_error.rb

@@ -1,7 +1,14 @@
 case RUBY_ENGINE
 when 'ruby'
-  require 'did_you_mean/method_missing'
+  name_error = begin
+    raise_name_error
+  rescue NameError => e
+    e
+  end
 
+  unless name_error.respond_to?(:receiver)
+    require 'did_you_mean/method_receiver'
+  end
 when 'jruby'
   NoMethodError.class_eval do
     def to_s
@@ -15,7 +22,7 @@ when 'jruby'
         field.setAccessible(true)
         field.get(__message__)
       rescue
-        super
+        nil
       end
     end
 
@@ -32,4 +39,8 @@ when 'jruby'
       end
     end
   end
+
+when 'rbx'
+  require 'did_you_mean/core_ext/rubinius'
+  NoMethodError.class_eval { attr_reader :receiver }
 end

data/lib/did_you_mean/core_ext/rubinius.rb

@@ -0,0 +1,16 @@
+if defined?(Rubinius)
+  class << Rubinius
+    alias raise_with_no_receiver_capturer raise_exception
+
+    def raise_exception(exc)
+      if exc.is_a?(NoMethodError)
+        bt = Rubinius::VM.backtrace(0, true).detect do |x|
+          x.method.name == :method_missing
+        end
+        exc.instance_variable_set(:@receiver, bt.variables.self) if bt
+      end
+
+      raise_with_no_receiver_capturer(exc)
+    end
+  end
+end

data/lib/did_you_mean/finders.rb

@@ -1,31 +1,62 @@
-require "did_you_mean/word_collection"
+require "did_you_mean/levenshtein"
+require "did_you_mean/jaro_winkler"
 
 module DidYouMean
   module BaseFinder
-    def did_you_mean?
-      return if similar_words.empty?
+    AT    = "@".freeze
+    EMPTY = "".freeze
 
-      output = "\n\n"
-      output << "    Did you mean? #{format(similar_words.first)}\n"
-      output << similar_words.drop(1).map{|word| "#{' ' * 18}#{format(word)}\n" }.join
-      output << " " # for pry
+    def suggestions
+      @suggestions ||= searches.flat_map do |input, candidates|
+        input     = normalize(input)
+        threshold = input.length > 3 ? 0.834 : 0.77
+
+        seed = candidates.select {|candidate| JaroWinkler.distance(normalize(candidate), input) >= threshold }
+          .sort_by! {|candidate| JaroWinkler.distance(candidate.to_s, input) }
+          .reverse!
+
+        # Correct mistypes
+        threshold   = (input.length * 0.25).ceil
+        corrections = seed.select {|c| Levenshtein.distance(normalize(c), input) <= threshold }
+
+        # Correct misspells
+        if corrections.empty?
+          corrections = seed.select do |candidate|
+            candidate = normalize(candidate)
+            length    = input.length < candidate.length ? input.length : candidate.length
+
+            Levenshtein.distance(candidate, input) < length
+          end.first(1)
+        end
+
+        corrections
+      end
     end
 
-    def similar_words
-      @similar_words ||= WordCollection.new(words).similar_to(target_word)
+    def searches
+      raise NotImplementedError
     end
-  end
 
-  class NullFinder
-    def initialize(*); end
-    def did_you_mean?; end
+    private
+
+    def normalize(str_or_symbol) #:nodoc:
+      str = if str_or_symbol.is_a?(String)
+              str_or_symbol.dup
+            else
+              str_or_symbol.to_s
+            end
+
+      str.downcase!
+      str.tr!(AT, EMPTY)
+      str
+    end
   end
 
-  def self.finders
-    @@finders ||= Hash.new(NullFinder)
+  class NullFinder
+    def initialize(*);  end
+    def suggestions; [] end
   end
 end
 
 require 'did_you_mean/finders/name_error_finders'
-require 'did_you_mean/finders/similar_attribute_finder'
-require 'did_you_mean/finders/similar_method_finder'
+require 'did_you_mean/finders/method_finder'

data/lib/did_you_mean/finders/method_finder.rb

@@ -0,0 +1,62 @@
+module DidYouMean
+  class MethodFinder
+    include BaseFinder
+    attr_reader :method_name, :receiver
+
+    def initialize(exception)
+      @method_name = exception.name
+      @receiver    = exception.receiver
+      @binding     = exception.frame_binding
+      @location    = exception.backtrace.first
+      @ivar_names  = NameFinder.new(exception).ivar_names
+    end
+
+    def searches
+      {
+        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.eval("self"))
+      method_names.delete(method_name)
+      method_names.uniq!
+      method_names
+    end
+
+    def receiver_name
+      return unless @receiver.nil?
+
+      abs_path, lineno, label =
+        /(.*):(.*):in `(.*)'/ =~ @location && [$1, $2.to_i, $3]
+
+      line =
+        case abs_path
+        when "(irb)"
+          Readline::HISTORY.to_a.last
+        when "(pry)"
+          ::Pry.history.to_a.last
+        else
+          File.open(abs_path) do |file|
+            file.detect { file.lineno == lineno }
+          end if File.exist?(abs_path)
+        end
+
+      /@(\w+)*\.#{@method_name}/ =~ line.to_s && $1
+    end
+  end
+
+  if RUBY_ENGINE == 'rbx'
+    module MethodFinder::RubiniusSupport
+      def self.new(exception)
+        if exception.receiver === exception.frame_binding.eval("self")
+          NameErrorFinders.new(exception)
+        else
+          MethodFinder.new(exception)
+        end
+      end
+    end
+  end
+end

data/lib/did_you_mean/finders/name_error_finders.rb

@@ -5,20 +5,17 @@ module DidYouMean
     end
 
     def self.new(exception)
-      klass = if /uninitialized constant/ =~ exception.original_message
-        SimilarClassFinder
-      elsif /undefined local variable or method/ =~ exception.original_message
-        SimilarNameFinder
+      case exception.original_message
+      when /uninitialized constant/
+        ClassFinder
+      when /undefined local variable or method/, /undefined method/, /uninitialized class variable/
+        NameFinder
       else
         NullFinder
-      end
-
-      klass.new(exception)
+      end.new(exception)
     end
   end
-
-  finders["NameError"] = NameErrorFinders
 end
 
-require 'did_you_mean/finders/name_error_finders/similar_name_finder'
-require 'did_you_mean/finders/name_error_finders/similar_class_finder'
+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

@@ -0,0 +1,77 @@
+require 'delegate'
+
+module DidYouMean
+  class ClassFinder
+    include BaseFinder
+    attr_reader :class_name, :original_message
+
+    def initialize(exception)
+      @class_name, @original_message = exception.name, exception.original_message
+    end
+
+    def searches
+      {name_from_message => class_names}
+    end
+
+    def class_names
+      scopes.flat_map do |scope|
+        scope.constants.map do |c|
+          ClassName.new(c, scope == Object ? EMPTY : "#{scope}::")
+        end
+      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
+    end
+
+    def suggestions
+      super.map(&:full_name)
+    end
+
+    def scopes
+      @scopes ||= scope_base.inject([Object]) do |_scopes, scope|
+        _scopes << _scopes.last.const_get(scope)
+      end
+    end
+
+    private
+
+    def scope_base
+      @scope_base ||= (/(([A-Z]\w*::)*)([A-Z]\w*)$/ =~ original_message ? $1 : "").split("::")
+    end
+
+    class ClassName < SimpleDelegator
+      attr :namespace
+
+      def initialize(name, namespace = '')
+        super(name)
+        @namespace = namespace
+      end
+
+      def full_name
+        self.class.new("#{namespace}#{__getobj__}")
+      end
+    end
+
+    private_constant :ClassName
+  end
+end

data/lib/did_you_mean/finders/name_error_finders/name_finder.rb

@@ -0,0 +1,18 @@
+module DidYouMean
+  class NameFinder
+    include BaseFinder
+    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.eval("local_variables")
+      @method_names = exception.frame_binding.eval("methods + private_methods")
+      @cvar_names   = exception.frame_binding.eval("self.class.class_variables")
+      @ivar_names   = exception.frame_binding.eval("instance_variables")
+    end
+
+    def searches
+      {name => (lvar_names + method_names + ivar_names + cvar_names)}
+    end
+  end
+end

data/lib/did_you_mean/formatter.rb

@@ -0,0 +1,20 @@
+module DidYouMean
+  class Formatter
+    def initialize(suggestions = [])
+      @suggestions = suggestions
+    end
+
+    def to_s
+      return "" if @suggestions.empty?
+
+      output = "\n\n"
+      output << "    Did you mean? #{format(@suggestions.first)}\n"
+      output << @suggestions.drop(1).map{|word| "#{' ' * 18}#{format(word)}\n" }.join
+      output << " " # for rspec
+    end
+
+    def format(name)
+      name
+    end
+  end
+end