did_you_mean 1.3.1 → 1.4.0

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

@@ -1,4 +1,4 @@
-require 'test_helper'
+require_relative '../helper'
 
 module ACRONYM
 end
@@ -27,44 +27,46 @@ class Book
   end
 end
 
-class ClassNameCheckTest < Minitest::Test
+class ClassNameCheckTest < Test::Unit::TestCase
+  include DidYouMean::TestHelper
+
   def test_corrections
-    error = assert_raises(NameError) { ::Bo0k }
+    error = assert_raise(NameError) { ::Bo0k }
     assert_correction "Book", error.corrections
   end
 
   def test_corrections_include_case_specific_class_name
-    error = assert_raises(NameError) { ::Acronym }
+    error = assert_raise(NameError) { ::Acronym }
     assert_correction "ACRONYM", error.corrections
   end
 
   def test_corrections_include_top_level_class_name
-    error = assert_raises(NameError) { Project.bo0k }
+    error = assert_raise(NameError) { Project.bo0k }
     assert_correction "Book", error.corrections
   end
 
   def test_names_in_corrections_have_namespaces
-    error = assert_raises(NameError) { ::Book::TableofContents }
+    error = assert_raise(NameError) { ::Book::TableofContents }
     assert_correction "Book::TableOfContents", error.corrections
   end
 
   def test_corrections_candidates_for_names_in_upper_level_scopes
-    error = assert_raises(NameError) { Book::Page.tableof_contents }
+    error = assert_raise(NameError) { Book::Page.tableof_contents }
     assert_correction "Book::TableOfContents", error.corrections
   end
 
   def test_corrections_should_work_from_within_instance_method
-    error = assert_raises(NameError) { ::Book.new.tableof_contents }
+    error = assert_raise(NameError) { ::Book.new.tableof_contents }
     assert_correction "Book::TableOfContents", error.corrections
   end
 
   def test_corrections_should_work_from_within_instance_method_on_nested_class
-    error = assert_raises(NameError) { ::Book::Page.new.tableof_contents }
+    error = assert_raise(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 }
+    error = assert_raise(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

data/test/spell_checking/{key_name_check_test.rb → test_key_name_check.rb}

@@ -1,14 +1,16 @@
-require "test_helper"
+require_relative '../helper'
+
+class KeyNameCheckTest < Test::Unit::TestCase
+  include DidYouMean::TestHelper
 
-class KeyNameCheckTest < Minitest::Test
   def test_corrects_hash_key_name_with_fetch
     hash = { "foo" => 1, bar: 2 }
 
-    error = assert_raises(KeyError) { hash.fetch(:bax) }
+    error = assert_raise(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") }
+    error = assert_raise(KeyError) { hash.fetch("fooo") }
     assert_correction %("foo"), error.corrections
     assert_match %(Did you mean?  "foo"), error.to_s
   end
@@ -16,17 +18,25 @@ class KeyNameCheckTest < Minitest::Test
   def test_corrects_hash_key_name_with_fetch_values
     hash = { "foo" => 1, bar: 2 }
 
-    error = assert_raises(KeyError) { hash.fetch_values("foo", :bar, :bax) }
+    error = assert_raise(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") }
+    error = assert_raise(KeyError) { hash.fetch_values("foo", :bar, "fooo") }
     assert_correction %("foo"), error.corrections
     assert_match %(Did you mean?  "foo"), error.to_s
   end
 
+  def test_correct_symbolized_hash_keys_with_string_value
+    hash = { foo_1: 1, bar_2: 2 }
+
+    error = assert_raise(KeyError) { hash.fetch('foo_1') }
+    assert_correction %(:foo_1), error.corrections
+    assert_match %(Did you mean?  :foo_1), error.to_s
+  end
+
   def test_corrects_sprintf_key_name
-    error = assert_raises(KeyError) { sprintf("%<foo>d", {fooo: 1}) }
+    error = assert_raise(KeyError) { sprintf("%<foo>d", {fooo: 1}) }
     assert_correction ":fooo", error.corrections
     assert_match "Did you mean?  :fooo", error.to_s
   end
@@ -34,7 +44,7 @@ class KeyNameCheckTest < Minitest::Test
   def test_corrects_env_key_name
     ENV["FOO"] = "1"
     ENV["BAR"] = "2"
-    error = assert_raises(KeyError) { ENV.fetch("BAX") }
+    error = assert_raise(KeyError) { ENV.fetch("BAX") }
     assert_correction %("BAR"), error.corrections
     assert_match %(Did you mean?  "BAR"), error.to_s
   ensure

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

@@ -1,6 +1,8 @@
-require 'test_helper'
+require_relative '../helper'
+
+class MethodNameCheckTest < Test::Unit::TestCase
+  include DidYouMean::TestHelper
 
-class MethodNameCheckTest < Minitest::Test
   class User
     def friends; end
     def first_name; end
@@ -36,50 +38,50 @@ class MethodNameCheckTest < Minitest::Test
   end
 
   def test_corrections_include_instance_method
-    error = assert_raises(NoMethodError){ @user.flrst_name }
+    error = assert_raise(NoMethodError){ @user.flrst_name }
 
     assert_correction :first_name, error.corrections
     assert_match "Did you mean?  first_name",  error.to_s
   end
 
   def test_corrections_include_private_method
-    error = assert_raises(NoMethodError){ @user.friend }
+    error = assert_raise(NoMethodError){ @user.friend }
 
     assert_correction :friends, error.corrections
     assert_match "Did you mean?  friends", error.to_s
   end
 
   def test_corrections_include_method_from_module
-    error = assert_raises(NoMethodError){ @user.fr0m_module }
+    error = assert_raise(NoMethodError){ @user.fr0m_module }
 
     assert_correction :from_module, error.corrections
     assert_match "Did you mean?  from_module", error.to_s
   end
 
   def test_corrections_include_class_method
-    error = assert_raises(NoMethodError){ User.l0ad }
+    error = assert_raise(NoMethodError){ User.l0ad }
 
     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 }
+    error = assert_raise(NoMethodError){ User.new.the_protected_method }
     refute_includes error.corrections, :the_protected_method
 
-    error = assert_raises(NoMethodError){ User.new.the_private_method }
+    error = assert_raise(NoMethodError){ User.new.the_private_method }
     refute_includes error.corrections, :the_private_method
   end
 
   def test_corrections_when_private_method_is_called_with_args
-    error = assert_raises(NoMethodError){ @user.call_incorrect_private_method }
+    error = assert_raise(NoMethodError){ @user.call_incorrect_private_method }
 
     assert_correction :raise, error.corrections
     assert_match "Did you mean?  raise", error.to_s
   end
 
   def test_exclude_methods_on_nil
-    error = assert_raises(NoMethodError){ nil.map }
+    error = assert_raise(NoMethodError){ nil.map }
     assert_empty error.corrections
   end
 
@@ -87,14 +89,14 @@ class MethodNameCheckTest < Minitest::Test
     def nil.empty?
     end
 
-    error = assert_raises(NoMethodError){ nil.empty }
+    error = assert_raise(NoMethodError){ nil.empty }
     assert_correction :empty?, error.corrections
   ensure
     NilClass.class_eval { undef empty? }
   end
 
   def test_does_not_append_suggestions_twice
-    error = assert_raises NoMethodError do
+    error = assert_raise NoMethodError do
       begin
         @user.firstname
       rescue NoMethodError => e
@@ -106,7 +108,7 @@ class MethodNameCheckTest < Minitest::Test
   end
 
   def test_does_not_append_suggestions_three_times
-    error = assert_raises NoMethodError do
+    error = assert_raise NoMethodError do
       begin
         @user.raise_no_method_error
       rescue NoMethodError => e
@@ -118,7 +120,7 @@ class MethodNameCheckTest < Minitest::Test
   end
 
   def test_suggests_corrections_on_nested_error
-    error = assert_raises NoMethodError do
+    error = assert_raise NoMethodError do
       begin
         @user.firstname
       rescue NoMethodError
@@ -130,7 +132,7 @@ class MethodNameCheckTest < Minitest::Test
   end
 
   def test_suggests_yield
-    error = assert_raises(NoMethodError) { yeild(1) }
+    error = assert_raise(NoMethodError) { yeild(1) }
 
     assert_correction :yield, error.corrections
     assert_match "Did you mean?  yield", error.to_s

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

@@ -1,10 +1,10 @@
-require 'test_helper'
+require_relative '../helper'
 
-class UncorrectableNameCheckTest < Minitest::Test
+class UncorrectableNameCheckTest < Test::Unit::TestCase
   class FirstNameError < NameError; end
 
   def setup
-    @error = assert_raises(FirstNameError) do
+    @error = assert_raise(FirstNameError) do
       raise FirstNameError, "Other name error"
     end
   end

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

@@ -1,6 +1,8 @@
-require 'test_helper'
+require_relative '../helper'
+
+class VariableNameCheckTest < Test::Unit::TestCase
+  include DidYouMean::TestHelper
 
-class VariableNameCheckTest < Minitest::Test
   class User
     def initialize
       @email_address = 'email_address@address.net'
@@ -27,7 +29,7 @@ class VariableNameCheckTest < Minitest::Test
   end
 
   def test_corrections_include_instance_method
-    error = assert_raises(NameError) do
+    error = assert_raise(NameError) do
       @user.instance_eval { flrst_name }
     end
 
@@ -41,7 +43,7 @@ class VariableNameCheckTest < Minitest::Test
   end
 
   def test_corrections_include_method_from_module
-    error = assert_raises(NameError) do
+    error = assert_raise(NameError) do
       @user.instance_eval { fr0m_module }
     end
 
@@ -52,7 +54,7 @@ class VariableNameCheckTest < Minitest::Test
   def test_corrections_include_local_variable_name
     if RUBY_ENGINE != "jruby"
       person = person = nil
-      error = (eprson rescue $!) # Do not use @assert_raises here as it changes a scope.
+      error = (eprson rescue $!) # Do not use @assert_raise here as it changes a scope.
 
       assert_correction :person, error.corrections
       assert_match "Did you mean?  person", error.to_s
@@ -60,21 +62,21 @@ class VariableNameCheckTest < Minitest::Test
   end
 
   def test_corrections_include_ruby_predefined_objects
-    some_var = nil
+    some_var = some_var = nil
 
-    false_error = assert_raises(NameError) do
+    false_error = assert_raise(NameError) do
       some_var = fals
     end
 
-    true_error = assert_raises(NameError) do
+    true_error = assert_raise(NameError) do
       some_var = treu
     end
 
-    nil_error = assert_raises(NameError) do
+    nil_error = assert_raise(NameError) do
       some_var = nul
     end
 
-    file_error = assert_raises(NameError) do
+    file_error = assert_raise(NameError) do
       __FIEL__
     end
 
@@ -92,21 +94,21 @@ class VariableNameCheckTest < Minitest::Test
   end
 
   def test_suggests_yield
-    error = assert_raises(NameError) { yeild }
+    error = assert_raise(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 }
+    error = assert_raise(NameError){ @user.to_s }
 
     assert_correction :@email_address, error.corrections
     assert_match "Did you mean?  @email_address", error.to_s
   end
 
   def test_corrections_include_private_method
-    error = assert_raises(NameError) do
+    error = assert_raise(NameError) do
       @user.instance_eval { cia_code_name }
     end
 
@@ -117,7 +119,7 @@ class VariableNameCheckTest < Minitest::Test
   @@does_exist = true
 
   def test_corrections_include_class_variable_name
-    error = assert_raises(NameError){ @@doesnt_exist }
+    error = assert_raise(NameError){ @@doesnt_exist }
 
     assert_correction :@@does_exist, error.corrections
     assert_match "Did you mean?  @@does_exist", error.to_s
@@ -125,14 +127,14 @@ class VariableNameCheckTest < Minitest::Test
 
   def test_struct_name_error
     value = Struct.new(:does_exist).new
-    error = assert_raises(NameError){ value[:doesnt_exist] }
+    error = assert_raise(NameError){ value[:doesnt_exist] }
 
     assert_correction [:does_exist, :does_exist=], error.corrections
     assert_match "Did you mean?  does_exist", error.to_s
   end
 
   def test_exclude_typical_incorrect_suggestions
-    error = assert_raises(NameError){ foo }
+    error = assert_raise(NameError){ foo }
     assert_empty error.corrections
   end
 end

data/test/{spell_checker_test.rb → test_spell_checker.rb}

@@ -1,6 +1,6 @@
-require 'test_helper'
+require_relative './helper'
 
-class SpellCheckerTest < Minitest::Test
+class SpellCheckerTest < Test::Unit::TestCase
   def test_spell_checker_corrects_mistypes
     assert_spell 'foo',   input: 'doo',   dictionary: ['foo', 'fork']
     assert_spell 'email', input: 'meail', dictionary: ['email', 'fail', 'eval']

data/test/test_tree_spell_checker.rb

@@ -0,0 +1,173 @@
+require 'set'
+require 'yaml'
+
+require_relative './helper'
+
+class TreeSpellCheckerTest < Test::Unit::TestCase
+  MINI_DIRECTORIES = YAML.load_file(File.expand_path('fixtures/mini_dir.yml', __dir__))
+  RSPEC_DIRECTORIES = YAML.load_file(File.expand_path('fixtures/rspec_dir.yml', __dir__))
+
+  def setup
+    @dictionary =
+      %w(
+        spec/models/concerns/vixen_spec.rb
+        spec/models/concerns/abcd_spec.rb
+        spec/models/concerns/vixenus_spec.rb
+        spec/models/concerns/efgh_spec.rb
+        spec/modals/confirms/abcd_spec.rb
+        spec/modals/confirms/efgh_spec.rb
+        spec/models/gafafa_spec.rb
+        spec/models/gfsga_spec.rb
+        spec/controllers/vixen_controller_spec.rb
+      )
+    @test_str = 'spek/modeks/confirns/viken_spec.rb'
+    @tsp = DidYouMean::TreeSpellChecker.new(dictionary: @dictionary)
+  end
+
+  def test_corrupt_root
+    word = 'test/verbose_formatter_test.rb'
+    word_error = 'btets/cverbose_formatter_etst.rb suggestions'
+    tsp = DidYouMean::TreeSpellChecker.new(dictionary: MINI_DIRECTORIES)
+    s = tsp.correct(word_error).first
+    assert_match s, word
+  end
+
+  def test_leafless_state
+    tsp = DidYouMean::TreeSpellChecker.new(dictionary: @dictionary.push('spec/features'))
+    word = 'spec/modals/confirms/efgh_spec.rb'
+    word_error = 'spec/modals/confirXX/efgh_spec.rb'
+    s = tsp.correct(word_error).first
+    assert_equal s, word
+    s = tsp.correct('spec/featuresXX')
+    assert_equal 'spec/features', s.first
+  end
+
+  def test_rake_dictionary
+    dict = %w(parallel:prepare parallel:create parallel:rake parallel:migrate)
+    word_error = 'parallel:preprare'
+    tsp = DidYouMean::TreeSpellChecker.new(dictionary: dict, separator: ':')
+    s = tsp.correct(word_error).first
+    assert_match s, 'parallel:prepare'
+  end
+
+  def test_special_words_mini
+    tsp = DidYouMean::TreeSpellChecker.new(dictionary: MINI_DIRECTORIES)
+    special_words_mini.each do |word, word_error|
+      s = tsp.correct(word_error).first
+      assert_match s, word
+    end
+  end
+
+  def test_special_words_rspec
+    tsp = DidYouMean::TreeSpellChecker.new(dictionary: RSPEC_DIRECTORIES)
+    special_words_rspec.each do |word, word_error|
+      s = tsp.correct(word_error)
+      assert_match s.first, word
+    end
+  end
+
+  def special_words_rspec
+    [
+      ['spec/rspec/core/formatters/exception_presenter_spec.rb','spec/rspec/core/formatters/eception_presenter_spec.rb'],
+      ['spec/rspec/core/ordering_spec.rb', 'spec/spec/core/odrering_spec.rb'],
+      ['spec/rspec/core/metadata_spec.rb', 'spec/rspec/core/metadata_spe.crb'],
+      ['spec/support/mathn_integration_support.rb', 'spec/support/mathn_itegrtion_support.rb']
+    ]
+  end
+
+  def special_words_mini
+    [
+     ['test/fixtures/book.rb', 'test/fixture/book.rb'],
+     ['test/fixtures/book.rb', 'test/fixture/book.rb'],
+     ['test/edit_distance/jaro_winkler_test.rb', 'test/edit_distace/jaro_winkler_test.rb'],
+     ['test/edit_distance/jaro_winkler_test.rb', 'teste/dit_distane/jaro_winkler_test.rb'],
+     ['test/fixtures/book.rb', 'test/fixturWes/book.rb'],
+     ['test/test_helper.rb', 'tes!t/test_helper.rb'],
+     ['test/fixtures/book.rb', 'test/hfixtures/book.rb'],
+     ['test/edit_distance/jaro_winkler_test.rb', 'test/eidt_distance/jaro_winkler_test.@rb'],
+     ['test/spell_checker_test.rb', 'test/spell_checke@r_test.rb'],
+     ['test/tree_spell_human_typo_test.rb', 'testt/ree_spell_human_typo_test.rb'],
+     ['test/spell_checking/variable_name_check_test.rb', 'test/spell_checking/vriabl_ename_check_test.rb'],
+     ['test/spell_checking/key_name_check_test.rb', 'tesit/spell_checking/key_name_choeck_test.rb'],
+     ['test/edit_distance/jaro_winkler_test.rb', 'test/edit_distance/jaro_winkler_tuest.rb']
+  ]
+  end
+
+  def test_file_in_root
+    word = 'test/spell_checker_test.rb'
+    word_error = 'test/spell_checker_test.r'
+    suggestions = DidYouMean::TreeSpellChecker.new(dictionary: MINI_DIRECTORIES).correct word_error
+    assert_equal word, suggestions.first
+  end
+
+  def test_no_plausible_states
+    word_error = 'testspell_checker_test.rb'
+    suggestions = DidYouMean::TreeSpellChecker.new(dictionary: MINI_DIRECTORIES).correct word_error
+    assert_equal [], suggestions
+  end
+
+  def test_no_plausible_states_with_augmentation
+    word_error = 'testspell_checker_test.rb'
+    suggestions = DidYouMean::TreeSpellChecker.new(dictionary: MINI_DIRECTORIES).correct word_error
+    assert_equal [], suggestions
+    suggestions = DidYouMean::TreeSpellChecker.new(dictionary: MINI_DIRECTORIES, augment: true).correct word_error
+    assert_equal 'test/spell_checker_test.rb', suggestions.first
+  end
+
+  def test_no_idea_with_augmentation
+    word_error = 'test/spell_checking/key_name.rb'
+    suggestions = DidYouMean::TreeSpellChecker.new(dictionary: MINI_DIRECTORIES).correct word_error
+    assert_equal [], suggestions
+    suggestions = DidYouMean::TreeSpellChecker.new(dictionary: MINI_DIRECTORIES, augment: true).correct word_error
+    assert_equal 'test/spell_checking/key_name_check_test.rb', suggestions.first
+  end
+
+  def test_works_out_suggestions
+    exp = ['spec/models/concerns/vixen_spec.rb',
+           'spec/models/concerns/vixenus_spec.rb']
+    suggestions = @tsp.correct(@test_str)
+    assert_equal suggestions.to_set, exp.to_set
+  end
+
+  def test_works_when_input_is_correct
+    correct_input = 'spec/models/concerns/vixenus_spec.rb'
+    suggestions = @tsp.correct correct_input
+    assert_equal suggestions.first, correct_input
+  end
+
+  def test_find_out_leaves_in_a_path
+    path = 'spec/modals/confirms'
+    names = @tsp.send(:find_leaves, path)
+    assert_equal names.to_set, %w(abcd_spec.rb efgh_spec.rb).to_set
+  end
+
+  def test_works_out_nodes
+    exp_paths = ['spec/models/concerns',
+                 'spec/models/confirms',
+                 'spec/modals/concerns',
+                 'spec/modals/confirms',
+                 'spec/controllers/concerns',
+                 'spec/controllers/confirms'].to_set
+    states = @tsp.send(:parse_dimensions)
+    nodes = states[0].product(*states[1..-1])
+    paths = @tsp.send(:possible_paths, nodes)
+    assert_equal paths.to_set, exp_paths.to_set
+  end
+
+  def test_works_out_state_space
+    suggestions = @tsp.send(:plausible_dimensions, @test_str)
+    assert_equal suggestions, [["spec"], ["models", "modals"], ["confirms", "concerns"]]
+  end
+
+  def test_parses_dictionary
+    states = @tsp.send(:parse_dimensions)
+    assert_equal states, [["spec"], ["models", "modals", "controllers"], ["concerns", "confirms"]]
+  end
+
+  def test_parses_elementary_dictionary
+    dictionary = ['spec/models/user_spec.rb', 'spec/services/account_spec.rb']
+    tsp = DidYouMean::TreeSpellChecker.new(dictionary: dictionary)
+    states = tsp.send(:parse_dimensions)
+    assert_equal states, [['spec'], ['models', 'services']]
+  end
+end