did_you_mean 1.3.0 → 1.6.1

data/test/test_ractor_compatibility.rb

@@ -0,0 +1,102 @@
+require_relative './helper'
+
+return if not DidYouMean::TestHelper.ractor_compatible?
+
+class RactorCompatibilityTest < Test::Unit::TestCase
+  include DidYouMean::TestHelper
+
+  class ::Book; end
+  class FirstNameError < NameError; end
+
+  def test_class_name_suggestion_works_in_ractor
+    error = Ractor.new {
+              begin
+                Boook
+              rescue NameError => e
+                e.corrections # It is important to call the #corrections method within Ractor.
+                e
+              end
+            }.take
+
+    assert_correction "Book", error.corrections
+  end
+
+  def test_key_name_suggestion_works_in_ractor
+    error = Ractor.new {
+              begin
+                hash = { "foo" => 1, bar: 2 }
+
+                hash.fetch(:bax)
+              rescue KeyError => e
+                e.corrections # It is important to call the #corrections method within Ractor.
+                e
+              end
+            }.take
+
+    assert_correction ":bar", error.corrections
+    assert_match "Did you mean?  :bar", error.to_s
+  end
+
+  def test_method_name_suggestion_works_in_ractor
+    error = Ractor.new {
+              begin
+                self.to__s
+              rescue NoMethodError => e
+                e.corrections # It is important to call the #corrections method within Ractor.
+                e
+              end
+            }.take
+
+    assert_correction :to_s, error.corrections
+    assert_match "Did you mean?  to_s",  error.to_s
+  end
+
+  if defined?(::NoMatchingPatternKeyError)
+    def test_pattern_key_name_suggestion_works_in_ractor
+      error = Ractor.new {
+                begin
+                  eval(<<~RUBY, binding, __FILE__, __LINE__)
+                          hash = {foo: 1, bar: 2, baz: 3}
+                          hash => {fooo:}
+                          fooo = 1 # suppress "unused variable: fooo" warning
+                  RUBY
+                rescue NoMatchingPatternKeyError => e
+                  e.corrections # It is important to call the #corrections method within Ractor.
+                  e
+                end
+              }.take
+
+      assert_correction ":foo", error.corrections
+      assert_match "Did you mean?  :foo", error.to_s
+    end
+  end
+
+  def test_can_raise_other_name_error_in_ractor
+    error = Ractor.new {
+      begin
+        raise FirstNameError, "Other name error"
+      rescue FirstNameError => e
+        e.corrections # It is important to call the #corrections method within Ractor.
+        e
+      end
+    }.take
+
+    assert_not_match(/Did you mean\?/, error.message)
+  end
+
+  def test_variable_name_suggestion_works_in_ractor
+    error = Ractor.new {
+      in_ractor = in_ractor = 1
+
+      begin
+        in_reactor
+      rescue NameError => e
+        e.corrections # It is important to call the #corrections method within Ractor.
+        e
+      end
+    }.take
+
+    assert_correction :in_ractor, error.corrections
+    assert_match "Did you mean?  in_ractor", error.to_s
+  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']
@@ -10,6 +10,7 @@ class SpellCheckerTest < Minitest::Test
     assert_spell 'eval',  input: 'veal',  dictionary: ['email', 'fail', 'eval']
     assert_spell 'sub!',  input: 'suv!',  dictionary: ['sub', 'gsub', 'sub!']
     assert_spell 'sub',   input: 'suv',   dictionary: ['sub', 'gsub', 'sub!']
+    assert_spell 'Foo',   input: 'FOo',   dictionary: ['Foo', 'FOo']
 
     assert_spell %w(gsub! gsub),     input: 'gsuv!', dictionary: %w(sub gsub gsub!)
     assert_spell %w(sub! sub gsub!), input: 'ssub!', dictionary: %w(sub sub! gsub gsub!)

data/test/test_tree_spell_checker.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+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"
+    @tree_spell_checker = DidYouMean::TreeSpellChecker.new(dictionary: @dictionary)
+  end
+
+  def test_corrupt_root
+    assert_tree_spell "test/verbose_formatter_test.rb",
+                      input: "btets/cverbose_formatter_etst.rb suggestions",
+                      dictionary: MINI_DIRECTORIES
+  end
+
+  def test_leafless_state
+    assert_tree_spell "spec/modals/confirms/efgh_spec.rb",
+                      input: "spec/modals/confirXX/efgh_spec.rb",
+                      dictionary: [*@dictionary, "spec/features"]
+
+    assert_tree_spell "spec/features",
+                      input: "spec/featuresXX",
+                      dictionary: [*@dictionary, "spec/features"]
+  end
+
+  def test_rake_dictionary
+    assert_tree_spell "parallel:prepare",
+                      input: "parallel:preprare",
+                      dictionary:  %w[parallel:prepare parallel:create parallel:rake parallel:migrate],
+                      separator: ":"
+  end
+
+  def test_special_words_mini
+    [
+      %w(test/fixtures/book.rb                           test/fixture/book.rb),
+      %w(test/edit_distance/jaro_winkler_test.rb         test/edit_distace/jaro_winkler_test.rb),
+      %w(test/edit_distance/jaro_winkler_test.rb         teste/dit_distane/jaro_winkler_test.rb),
+      %w(test/fixtures/book.rb                           test/fixturWes/book.rb),
+      %w(test/test_helper.rb                             tes!t/test_helper.rb),
+      %w(test/fixtures/book.rb                           test/hfixtures/book.rb),
+      %w(test/edit_distance/jaro_winkler_test.rb         test/eidt_distance/jaro_winkler_test.@rb),
+      %w(test/spell_checker_test.rb                      test/spell_checke@r_test.rb),
+      %w(test/tree_spell_human_typo_test.rb              testt/ree_spell_human_typo_test.rb),
+      %w(test/edit_distance/jaro_winkler_test.rb         test/edit_distance/jaro_winkler_tuest.rb),
+    ].each do |expected, user_input|
+      assert_tree_spell expected, input: user_input, dictionary: MINI_DIRECTORIES
+    end
+
+    [
+      %w(test/spell_checking/variable_name_check_test.rb test/spell_checking/vriabl_ename_check_test.rb),
+      %w(test/spell_checking/key_name_check_test.rb      tesit/spell_checking/key_name_choeck_test.rb),
+    ].each do |expected, user_input|
+      assert_equal expected, DidYouMean::TreeSpellChecker.new(dictionary: MINI_DIRECTORIES).correct(user_input)[0]
+    end
+  end
+
+  def test_special_words_rspec
+    [
+      %w(spec/rspec/core/formatters/exception_presenter_spec.rb spec/rspec/core/formatters/eception_presenter_spec.rb),
+      %w(spec/rspec/core/metadata_spec.rb                       spec/rspec/core/metadata_spe.crb),
+      %w(spec/rspec/core/ordering_spec.rb                       spec/spec/core/odrering_spec.rb),
+      %w(spec/support/mathn_integration_support.rb              spec/support/mathn_itegrtion_support.rb),
+    ].each do |expected, user_input|
+      assert_tree_spell expected, input: user_input, dictionary: RSPEC_DIRECTORIES
+    end
+  end
+
+  def test_file_in_root
+    assert_tree_spell "test/spell_checker_test.rb", input: "test/spell_checker_test.r", dictionary: MINI_DIRECTORIES
+  end
+
+  def test_no_plausible_states
+    assert_tree_spell [], input: "testspell_checker_test.rb", dictionary: MINI_DIRECTORIES
+  end
+
+  def test_no_plausible_states_with_augmentation
+    assert_tree_spell [], input: "testspell_checker_test.rb", dictionary: MINI_DIRECTORIES
+
+    suggestions = DidYouMean::TreeSpellChecker.new(dictionary: MINI_DIRECTORIES, augment: true).correct("testspell_checker_test.rb")
+
+    assert_equal suggestions.first, "test/spell_checker_test.rb"
+  end
+
+  def test_no_idea_with_augmentation
+    assert_tree_spell [], input: "test/spell_checking/key_name.rb", dictionary: MINI_DIRECTORIES
+
+    suggestions = DidYouMean::TreeSpellChecker.new(dictionary: MINI_DIRECTORIES, augment: true).correct("test/spell_checking/key_name.rb")
+
+    assert_equal suggestions.first, "test/spell_checking/key_name_check_test.rb"
+  end
+
+  def test_works_out_suggestions
+    assert_tree_spell %w(spec/models/concerns/vixen_spec.rb spec/models/concerns/vixenus_spec.rb),
+                      input: "spek/modeks/confirns/viken_spec.rb",
+                      dictionary: %w(spec/models/concerns/vixen_spec.rb spec/models/concerns/vixenus_spec.rb)
+  end
+
+  def test_works_when_input_is_correct
+    assert_tree_spell "spec/models/concerns/vixenus_spec.rb",
+                      input: "spec/models/concerns/vixenus_spec.rb",
+                      dictionary: @dictionary
+  end
+
+  def test_find_out_leaves_in_a_path
+    names = @tree_spell_checker.find_leaves("spec/modals/confirms")
+
+    assert_equal %w[abcd_spec.rb efgh_spec.rb], names
+  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"]
+
+    states = @tree_spell_checker.dimensions
+    nodes  = states[0].product(*states[1..-1])
+    paths  = @tree_spell_checker.possible_paths(nodes)
+
+    assert_equal paths, exp_paths
+  end
+
+  def test_works_out_state_space
+    suggestions = @tree_spell_checker.plausible_dimensions(@test_str)
+
+    assert_equal [["spec"], %w[models modals], %w[confirms concerns]], suggestions
+  end
+
+  def test_parses_dictionary
+    states = @tree_spell_checker.dimensions
+
+    assert_equal [["spec"], %w[models modals controllers], %w[concerns confirms]], states
+  end
+
+  def test_parses_elementary_dictionary
+    dimensions = DidYouMean::TreeSpellChecker
+                   .new(dictionary: %w(spec/models/user_spec.rb spec/services/account_spec.rb))
+                   .dimensions
+
+    assert_equal [["spec"], %w[models services]], dimensions
+  end
+
+  private
+
+  def assert_tree_spell(expected, input:, dictionary:, separator: "/")
+    suggestions = DidYouMean::TreeSpellChecker.new(dictionary: dictionary, separator: separator).correct(input)
+
+    assert_equal Array(expected), suggestions, "Expected to suggest #{expected}, but got #{suggestions.inspect}"
+  end
+end

data/test/tree_spell/change_word.rb

@@ -0,0 +1,61 @@
+module TreeSpell
+  # Changes a word with one of four actions:
+  # insertion, substitution, deletion and transposition.
+  class ChangeWord
+    # initialize with input string
+    def initialize(input)
+      @input = input
+      @len = input.length
+    end
+
+    # insert char after index of i_place
+    def insertion(i_place, char)
+      @word = input.dup
+      return char + word if i_place == 0
+      return word + char if i_place == len - 1
+      word.insert(i_place + 1, char)
+    end
+
+    # substitute char at index of i_place
+    def substitution(i_place, char)
+      @word = input.dup
+      word[i_place] = char
+      word
+    end
+
+    # delete character at index of i_place
+    def deletion(i_place)
+      @word = input.dup
+      word.slice!(i_place)
+      word
+    end
+
+    # transpose char at i_place with char at i_place + direction
+    # if i_place + direction is out of bounds just swap in other direction
+    def transposition(i_place, direction)
+      @word = input.dup
+      w = word.dup
+      return  swap_first_two(w) if i_place + direction < 0
+      return  swap_last_two(w) if i_place + direction >= len
+      swap_two(w, i_place, direction)
+      w
+    end
+
+    private
+
+    attr_accessor :word, :input, :len
+
+    def swap_first_two(w)
+      w[1] + w[0] + word[2..-1]
+    end
+
+    def swap_last_two(w)
+      w[0...(len - 2)] + word[len - 1] + word[len - 2]
+    end
+
+    def swap_two(w, i_place, direction)
+      w[i_place] = word[i_place + direction]
+      w[i_place + direction] = word[i_place]
+    end
+  end
+end

data/test/tree_spell/human_typo.rb

@@ -0,0 +1,69 @@
+# module for classes needed to test TreeSpellChecker
+module TreeSpell
+  require_relative 'change_word'
+  # Simulate an error prone human typist
+  # see doc/human_typo_api.md for the api description
+  class HumanTypo
+    POPULAR_CHARS = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ?<>,.!`+=-_":;@#$%^&*()'.split("").freeze
+    ACTION_TYPES  = %i(insert transpose delete substitute).freeze
+
+    def initialize(input, lambda: 0.05)
+      @input = input
+      check_input
+      @len = input.length
+      @lambda = lambda
+    end
+
+    def call
+      @word = input.dup
+      i_place = initialize_i_place
+      loop do
+        action = ACTION_TYPES.sample
+        @word = make_change action, i_place
+        @len = word.length
+        i_place += exponential
+        break if i_place >= len
+      end
+      word
+    end
+
+    private
+
+    attr_accessor :input, :word, :len, :lambda
+
+    def initialize_i_place
+      i_place = nil
+      loop do
+        i_place = exponential
+        break if i_place < len
+      end
+      i_place
+    end
+
+    def exponential
+      (rand / (lambda / 2)).to_i
+    end
+
+    def make_change(action, i_place)
+      cw = ChangeWord.new(word)
+      case action
+      when :delete
+        cw.deletion(i_place)
+      when :insert
+        cw.insertion(i_place, POPULAR_CHARS.sample)
+      when :substitute
+        cw.substitution(i_place, POPULAR_CHARS.sample)
+      when :transpose
+        cw.transposition(i_place, rand >= 0.5 ? +1 : -1)
+      end
+    end
+
+    def check_input
+      fail check_input_message if input.nil? || input.length < 5
+    end
+
+    def check_input_message
+      "input length must be greater than 5 characters: #{input}"
+    end
+  end
+end

data/test/tree_spell/test_change_word.rb

@@ -0,0 +1,38 @@
+require_relative '../helper'
+require_relative 'change_word'
+
+class ChangeWordTest < Test::Unit::TestCase
+  def setup
+    @input = 'spec/services/anything_spec'
+    @cw = TreeSpell::ChangeWord.new(@input)
+    @len = @input.length
+  end
+
+  def test_deletion
+    assert_match @cw.deletion(5), 'spec/ervices/anything_spec'
+    assert_match @cw.deletion(@len - 1), 'spec/services/anything_spe'
+    assert_match @cw.deletion(0), 'pec/services/anything_spec'
+  end
+
+  def test_substitution
+    assert_match @cw.substitution(5, '$'), 'spec/$ervices/anything_spec'
+    assert_match @cw.substitution(@len - 1, '$'), 'spec/services/anything_spe$'
+    assert_match @cw.substitution(0, '$'), '$pec/services/anything_spec'
+  end
+
+  def test_insertion
+    assert_match @cw.insertion(7, 'X'), 'spec/serXvices/anything_spec'
+    assert_match @cw.insertion(0, 'X'), 'Xspec/services/anything_spec'
+    assert_match @cw.insertion(@len - 1, 'X'), 'spec/services/anything_specX'
+  end
+
+  def test_transposition
+    n = @input.length
+    assert_match @cw.transposition(0, -1), 'psec/services/anything_spec'
+    assert_match @cw.transposition(n - 1, +1), 'spec/services/anything_spce'
+    assert_match @cw.transposition(4, +1), 'specs/ervices/anything_spec'
+    assert_match @cw.transposition(4, -1), 'spe/cservices/anything_spec'
+    assert_match @cw.transposition(21, -1), 'spec/services/anythign_spec'
+    assert_match @cw.transposition(21, +1), 'spec/services/anythin_gspec'
+  end
+end

data/test/tree_spell/test_explore.rb

@@ -0,0 +1,128 @@
+require 'set'
+require 'yaml'
+
+require_relative '../helper'
+require_relative 'human_typo'
+
+# statistical tests on tree_spell algorithms
+class ExploreTest < 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 test_checkers_with_many_typos_on_mini
+    n_repeat = 10_000
+    many_typos n_repeat, MINI_DIRECTORIES, 'Minitest'
+  end
+
+  def test_checkers_with_many_typos_on_rspec
+    n_repeat = 10_000
+    many_typos n_repeat, RSPEC_DIRECTORIES, 'Rspec'
+  end
+
+  def test_human_typo
+    n_repeat = 10_000
+    total_changes = 0
+    word = 'any_string_that_is_40_characters_long_sp'
+    n_repeat.times do
+      word_error = TreeSpell::HumanTypo.new(word).call
+      total_changes += DidYouMean::Levenshtein.distance(word, word_error)
+    end
+    mean_changes = (total_changes.to_f / n_repeat).round(2)
+    puts ''
+    puts "HumanTypo mean_changes: #{mean_changes} with n_repeat: #{n_repeat}"
+    puts 'Expected  mean_changes: 2.1 with n_repeat: 10000, plus/minus 0.03'
+    puts ''
+  end
+
+  def test_execution_speed
+    n_repeat = 1_000
+    puts ''
+    puts 'Testing execution time of Standard'
+    measure_execution_speed(n_repeat) do |files, error|
+      DidYouMean::SpellChecker.new(dictionary: files).correct error
+    end
+    puts ''
+    puts 'Testing execution time of Tree'
+    measure_execution_speed(n_repeat) do |files, error|
+      DidYouMean::TreeSpellChecker.new(dictionary: files).correct error
+    end
+    puts ''
+    puts 'Testing execution time of Augmented Tree'
+    measure_execution_speed(n_repeat) do |files, error|
+      DidYouMean::TreeSpellChecker.new(dictionary: files, augment: true).correct error
+    end
+  end
+
+  private
+
+  def measure_execution_speed(n_repeat, &block)
+    len = RSPEC_DIRECTORIES.length
+    start_time = Time.now
+    n_repeat.times do
+      word = RSPEC_DIRECTORIES[rand len]
+      word_error = TreeSpell::HumanTypo.new(word).call
+      block.call(RSPEC_DIRECTORIES, word_error)
+    end
+    time_ms = (Time.now - start_time).to_f * 1000 / n_repeat
+    puts "Average time (ms): #{time_ms.round(1)}"
+  end
+
+  def many_typos(n_repeat, files, title)
+    first_times = [0, 0, 0]
+    total_suggestions = [0, 0, 0]
+    total_failures = [0, 0, 0]
+    len = files.length
+    n_repeat.times do
+      word = files[rand len]
+      word_error = TreeSpell::HumanTypo.new(word).call
+      suggestions_a = group_suggestions word_error, files
+      check_first_is_right word, suggestions_a, first_times
+      check_no_suggestions suggestions_a, total_suggestions
+      check_for_failure word, suggestions_a, total_failures
+    end
+    print_results first_times, total_suggestions, total_failures, n_repeat, title
+  end
+
+  def group_suggestions(word_error, files)
+    a0 = DidYouMean::TreeSpellChecker.new(dictionary: files).correct word_error
+    a1 = ::DidYouMean::SpellChecker.new(dictionary: files).correct word_error
+    a2 =  a0.empty? ? a1 : a0
+    [a0, a1, a2]
+  end
+
+  def check_for_failure(word, suggestions_a, total_failures)
+    suggestions_a.each_with_index.map do |a, i|
+      total_failures[i] += 1 unless a.include? word
+    end
+  end
+
+  def check_first_is_right(word, suggestions_a, first_times)
+    suggestions_a.each_with_index.map do |a, i|
+      first_times[i] += 1 if word == a.first
+    end
+  end
+
+  def check_no_suggestions(suggestions_a, total_suggestions)
+    suggestions_a.each_with_index.map do |a, i|
+      total_suggestions[i] += a.length
+    end
+  end
+
+  def print_results(first_times, total_suggestions, total_failures, n_repeat, title)
+    algorithms = ['Tree     ', 'Standard ', 'Augmented']
+    print_header title
+    (0..2).each do |i|
+      ft = (first_times[i].to_f / n_repeat * 100).round(1)
+      mns = (total_suggestions[i].to_f / (n_repeat - total_failures[i])).round(1)
+      f = (total_failures[i].to_f / n_repeat * 100).round(1)
+      puts " #{algorithms[i]}  #{' ' * 7}  #{ft} #{' ' * 14} #{mns} #{' ' * 15} #{f} #{' ' * 16}"
+    end
+  end
+
+  def print_header(title)
+    puts "#{' ' * 30} #{title} Summary #{' ' * 31}"
+    puts '-' * 80
+    puts " Method  |   First Time (\%)    Mean Suggestions       Failures (\%) #{' ' * 13}"
+    puts '-' * 80
+  end
+end

data/test/tree_spell/test_human_typo.rb

@@ -0,0 +1,24 @@
+require_relative '../helper'
+require_relative 'human_typo'
+
+class HumanTypoTest < Test::Unit::TestCase
+  def setup
+    @input = 'spec/services/anything_spec'
+    @sh = TreeSpell::HumanTypo.new(@input, lambda: 0.05)
+    @len = @input.length
+  end
+
+  def test_changes
+    # srand seed ensures all four actions are called
+    srand 247_696_449
+    sh = TreeSpell::HumanTypo.new(@input, lambda: 0.20)
+    word_error = sh.call
+    assert_equal word_error, 'spec/suervcieq/anythin_gpec'
+  end
+
+  def test_check_input
+    assert_raise(RuntimeError, "input length must be greater than 5 characters: tiny") do
+      TreeSpell::HumanTypo.new('tiny')
+    end
+  end
+end