did_you_mean 0.9.10-java → 0.10.0-java

data/gemfiles/activerecord_edge.gemfile

@@ -1,25 +0,0 @@
-# This file was generated by Appraisal
-
-source "https://rubygems.org"
-
-git "git://github.com/rails/rails.git" do
-  gem "activerecord", :require => "activerecord"
-end
-
-gem "arel", :github => "rails/arel"
-
-platforms :ruby do
-  gem "sqlite3"
-end
-
-platforms :jruby do
-  gem "activerecord-jdbcsqlite3-adapter"
-end
-
-platforms :rbx do
-  gem "rubysl", "~> 2.0"
-  gem "racc"
-  gem "rubinius-developer_tools"
-end
-
-gemspec :path => "../"

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

@@ -1,50 +0,0 @@
-module DidYouMean
-  class SimilarClassFinder
-    include BaseFinder
-    attr_reader :class_name, :original_message
-
-    def initialize(exception)
-      @class_name, @original_message = exception.name, exception.original_message
-    end
-
-    def words
-      scopes.flat_map do |scope|
-        scope.constants.map {|name| ConstantName.new(name, scope) }
-      end
-    end
-
-    def name_from_message
-      class_name || /([A-Z]\w*$)/.match(original_message)[0]
-    end
-    alias target_word name_from_message
-
-    def similar_words
-      super.map(&:full_name)
-    end
-
-    def scopes
-      @scopes ||= scope_base.size.times.map do |count|
-        eval(scope_base[0..(- count)].join("::"))
-      end.reverse << Object
-    end
-
-    private
-
-    def scope_base
-      @scope_base ||= (/(([A-Z]\w*::)*)([A-Z]\w*)$/ =~ original_message ? $1 : "").split("::")
-    end
-
-    class ConstantName < String
-      attr_reader :scope
-
-      def initialize(str, scope)
-        super(str.to_s)
-        @scope = scope.to_s
-      end
-
-      def full_name
-        scope == "Object" ? to_s : "#{scope}::#{to_s}"
-      end
-    end
-  end
-end

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

@@ -1,61 +0,0 @@
-module DidYouMean
-  class SimilarNameFinder
-    include BaseFinder
-    attr_reader :name, :_methods, :_local_variables, :_instance_variables
-
-    def initialize(exception)
-      @name             = exception.name
-      @_methods         = exception.frame_binding.eval("methods")
-      @_local_variables = exception.frame_binding.eval("local_variables")
-      @_instance_variables = exception.frame_binding.eval("instance_variables").map do |name|
-        name.to_s.tr("@", "")
-      end
-    end
-
-    def words
-      local_variable_names + method_names + instance_variable_names
-    end
-
-    alias target_word name
-
-    def local_variable_names
-      _local_variables.map {|word| LocalVariableName.new(word.to_s) }
-    end
-
-    def similar_local_variables
-      similar_words.select{|word| word.is_a?(LocalVariableName) }
-    end
-
-    def method_names
-      _methods.map {|word| MethodName.new(word.to_s) }
-    end
-
-    def similar_methods
-      similar_words.select{|word| word.is_a?(MethodName) }
-    end
-
-    def instance_variable_names
-      _instance_variables.map {|word| InstanceVariableName.new(word.to_s) }
-    end
-
-    def similar_instance_variables
-      similar_words.select {|word| word.is_a?(InstanceVariableName) }
-    end
-
-    def format(word)
-      "#{word.prefix}#{word}"
-    end
-
-    class MethodName < String
-      def prefix; "#"; end
-    end
-
-    class LocalVariableName < String
-      def prefix; ""; end
-    end
-
-    class InstanceVariableName < String
-      def prefix; "@"; end
-    end
-  end
-end

data/lib/did_you_mean/finders/similar_attribute_finder.rb

@@ -1,26 +0,0 @@
-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

@@ -1,34 +0,0 @@
-module DidYouMean
-  class SimilarMethodFinder
-    include BaseFinder
-    attr_reader :method_name, :receiver
-
-    def initialize(exception)
-      @method_name, @receiver = exception.name, exception.receiver
-    end
-
-    def words
-      method_names = receiver.methods + receiver.singleton_methods
-      method_names.delete(@method_name)
-      method_names.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 RUBY_ENGINE == 'ruby' || RUBY_ENGINE == 'jruby'
-    finders["NoMethodError"] = SimilarMethodFinder
-  end
-end

data/lib/did_you_mean/word_collection.rb

@@ -1,30 +0,0 @@
-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)
-
-      map {|word| [Levenshtein.distance(word.to_s, target_word), word] }
-        .select {|distance, _| distance <= threshold }
-        .sort
-        .map(&:last)
-    end
-
-    private
-
-    def threshold(word)
-      (word.size * 0.3).ceil
-    end
-  end
-end

data/test/all_test.rb

@@ -1,18 +0,0 @@
-require_relative 'null_finder_test'
-require_relative 'word_collection_test'
-require_relative 'name_error_extension_test'
-require_relative 'similar_name_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

@@ -1,73 +0,0 @@
-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
-
-  def test_to_s_does_not_make_disruptive_changes_to_error_message
-    error = assert_raises(NameError) do
-      raise NameError, "uninitialized constant Object".freeze
-    end
-
-    assert_equal 1, error.to_s.scan("Y U SO SLOW?").count
-  end
-end
-
-class IgnoreCallersTest < Minitest::Test
-  class Boomer
-    def initialize(*)
-      raise Exception, "finder was created when it shouldn't!"
-    end
-  end
-
-  def setup
-    @org = DidYouMean.finders["NameError"]
-    DidYouMean.finders["NameError"] = Boomer
-
-    @error = assert_raises(NameError){ doesnt_exist }
-  end
-
-  def teardown
-    DidYouMean.finders["NameError"] = @org
-  end
-
-  def test_ignore_missing_name
-    assert_nothing_raised { missing_name }
-  end
-
-  def test_ignore_safe_constantize
-    assert_nothing_raised { safe_constantize }
-  end
-
-  private
-
-  def safe_constantize
-    @error.message
-  end
-
-  def missing_name
-    @error.message
-  end
-
-  def assert_nothing_raised
-    yield
-  end
-end

data/test/similar_attribute_finder_test.rb

@@ -1,17 +0,0 @@
-require_relative 'test_helper'
-
-class SimilarAttributeFinderTest < Minitest::Test
-  def setup
-    @error = assert_raises(ActiveRecord::UnknownAttributeError) do
-      User.new(flrst_name: "wrong flrst name")
-    end
-  end
-
-  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
-end

data/test/similar_class_finder_test.rb

@@ -1,85 +0,0 @@
-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

@@ -1,60 +0,0 @@
-require_relative 'test_helper'
-
-class SimilarMethodFinderTest < Minitest::Test
-  class User
-    def friends; end
-    def first_name; end
-    def descendants; end
-
-    protected
-    def the_protected_method; end
-
-    private
-    def friend; end
-    def the_private_method; end
-
-    class << self
-      def load; end
-    end
-  end
-
-  module UserModule
-    def from_module; end
-  end
-
-  def setup
-    user = User.new.extend(UserModule)
-
-    @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_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",  @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_similar_words_for_long_method_name
-    error = assert_raises(NoMethodError){ User.new.dependents }
-    assert_suggestion error.finder.similar_words, :descendants
-  end
-
-  def test_private_methods_should_not_be_suggested
-    error = assert_raises(NoMethodError){ User.new.the_protected_method }
-    refute_includes error.finder.similar_words, 'the_protected_method'
-
-    error = assert_raises(NoMethodError){ User.new.the_private_method }
-    refute_includes error.finder.similar_words, 'the_private_method'
-  end
-end