did_you_mean 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '05887ae70010eb1df6b01afa6dc40a0b2831040983baf01a58dedc31a02e179a'
-  data.tar.gz: ac63168212e43e8d4161c6a32632081f8c93f1a9c90279b654c7464119a2fefe
+  metadata.gz: 3befc8f677ec57e2975d04b2095fcecf7314ff207150aa994b197894dba883af
+  data.tar.gz: dc5a44ad2f6058ef68913f4080a23141f39b23f3b30129fe753d5d88cca85cc0
 SHA512:
-  metadata.gz: 2aeccb65107c3f3f1fd8f084c173d914c5dc4e0827826372b22c3d7b9dbd3532c0e6dad043a194a7860ccc10df671b8b3008292d95bce26953f282a4d7c2a061
-  data.tar.gz: f7b276aa466cbace238442d1fd3acc9a26a3b2b3623b5cb330b7b1dee15e9916b5a9140d5a74cb585586e30b95d371dbd02a97f7bad81f82b542517299c2df95
+  metadata.gz: 4d60d78614d4a6650b2be87599d3c3d867ab74f4cdf7f6083594229e3c51588af57a5c9574ca35ced229558f4280cd3677cbd7944cc5cef55e34a4f7ff7addf3
+  data.tar.gz: df5f07a5893afee4e03af416230ee828c7c2c2dfb8e5e35b5c525bebdff03710645b4af192563dc546abd4c210f8f2e8ce15e90124503488b74db19bd700f71c

data/.github/workflows/ruby.yml

@@ -13,36 +13,27 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby: [ '2.5.4', '2.6.5', 'ruby-head', 'jruby-9.2.9.0', 'jruby-head' ]
+        ruby: [ '2.5.8', '2.6.6', '2.7.1', 'ruby-head', 'jruby-9.2.11.1', 'jruby-head' ]
     steps:
     - uses: actions/checkout@v1
-    - name: Set up RVM
-      run: |
-        curl -sSL https://get.rvm.io | bash
-    - name: Set up Ruby
-      run: |
-        source $HOME/.rvm/scripts/rvm
-        rvm install ${{ matrix.ruby }} --binary
-        rvm --default use ${{ matrix.ruby }}
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
     - name: Build and test with Rake
       run: |
-        source $HOME/.rvm/scripts/rvm
         gem i test-unit
-        rake
+        RUBYOPT='--disable-did_you_mean' rake
 
   benchmark:
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v1
-    - name: Set up Ruby 2.6
-      uses: actions/setup-ruby@v1
+    - uses: ruby/setup-ruby@v1
       with:
-        ruby-version: 2.6.x
+        ruby-version: 2.7.1
     - name: Test performance and accuracy
       run: |
         gem install bundler
         bundle install --jobs 4 --retry 2
-        gem uni did_you_mean
-        bundle exec rake test:accuracy
-        bundle exec rake test:explore
-        bundle exec rake benchmark:memory
+        RUBYOPT='--disable-did_you_mean' bundle exec rake test:accuracy
+        RUBYOPT='--disable-did_you_mean' bundle exec rake benchmark:memory

data/CHANGELOG.md

@@ -1,7 +1,41 @@
-## v1.4.0 (Next)
+## v1.5.0
 
-- Remove the empty `tmp/` directory to comply with `rpmlint` ([#122](https://github.com/ruby/did_you_mean/issues/122))
-- Fixes a bug where suggestions are not shown on subsequent errors ([#120](https://github.com/ruby/did_you_mean/issues/120))
+ - Suggest require paths on LoadError ([#143](https://github.com/ruby/did_you_mean/pull/143))
+
+## [v1.4.0](https://github.com/ruby/did_you_mean/tree/v1.4.0)
+
+_<sup>released at 2020-05-09 02:56:43 UTC</sup>_
+
+As of Ruby 2.7, the `did_you_mean` gem has been promoted up to a default gem. I would like to thank [@kddeisz](https://github.com/kddeisz) for his hard work on making the entire gem easily portable the main ruby/ruby repo ([#132](https://github.com/ruby/did_you_mean/pull/132), [#131](https://github.com/ruby/did_you_mean/pull/131), and [ruby/ruby#2631](https://github.com/ruby/ruby/pull/2631)).
+
+#### Features
+
+- Add a new tree spell checker ([#119](https://github.com/ruby/did_you_mean/pull/119), [@obromios](https://github.com/obromios))
+- Add a public API for registering an error ([#123](https://github.com/ruby/did_you_mean/pull/123), [@kddeisz](https://github.com/kddeisz))
+
+#### Bug fixes
+
+- Fixes a bug where wrong suggestion could be made when string requested on hash and keys are symbols ([@localhostdotdev](https://github.com/localhostdotdev), [#134](https://github.com/ruby/did_you_mean/pull/134))
+
+#### Breaking changes
+
+- Experimental features have been removed ([#135](https://github.com/ruby/did_you_mean/pull/135))
+
+#### Internal changes
+
+- Replace Travis CI with GitHub Actions ([#124](https://github.com/ruby/did_you_mean/pull/124))
+- Drop mintiest dependency ([#129](https://github.com/ruby/did_you_mean/pull/129))
+- Drop delegate dependency ([#138](https://github.com/ruby/did_you_mean/pull/138))
+
+## [v1.3.1](https://github.com/ruby/did_you_mean/tree/v1.3.1)
+
+_<sup>released at 2019-09-29 03:58:46 UTC</sup>_
+
+#### Bug fixes
+
+- Fixes a test failure in Ruby core where DYM attempts to mutate immutable strings from `Symbol#to_s` ([#125](https://github.com/ruby/did_you_mean/pull/125), [@nobu](https://github.com/nobu), [@eregon](https://github.com/eregon), [@MSP-Greg](https://github.com/MSP-Greg))
+- Removes the empty `tmp/` directory to comply with `rpmlint` ([#122](https://github.com/ruby/did_you_mean/issues/122), [@pvalena](https://github.com/pvalena))
+- Fixes a bug where suggestions are not shown on subsequent errors ([#120](https://github.com/ruby/did_you_mean/issues/120), [@localhostdotdev](https://github.com/localhostdotdev))
 
 ## [v1.3.0](https://github.com/ruby/did_you_mean/tree/v1.3.0)
 

data/README.md

@@ -61,6 +61,14 @@ hash.fetch(:fooo)
 #    Did you mean?  :foo
 ```
 
+### LoadError
+
+```ruby
+require 'net-http'
+# => LoadError (cannot load such file -- net-http)
+#    Did you mean?  net/http
+```
+
 ## Verbose Formatter
 
 This verbose formatter changes the error message format to take more lines/spaces so it'll be slightly easier to read the suggestions. This formatter can totally be used in any environment including production.

data/Rakefile

@@ -7,13 +7,16 @@ Rake::TestTask.new do |task|
   task.test_files = Dir['test/**/test_*.rb'].reject {|path| path.end_with?("test_explore.rb") }
   task.verbose    = true
   task.warning    = true
+  task.ruby_opts  = %w[ --disable-did_you_mean ]
 end
 
 Rake::TestTask.new("test:explore") do |task|
   task.libs << "test"
-  task.pattern = 'test/tree_spell/test_explore.rb'
-  task.verbose = true
-  task.warning = true
+
+  task.pattern   = 'test/tree_spell/test_explore.rb'
+  task.verbose   = true
+  task.warning   = true
+  task.ruby_opts = %w[ --disable-did_you_mean ]
 end
 
 task default: %i(test)
@@ -22,7 +25,7 @@ namespace :test do
   namespace :accuracy do
     desc "Download Wiktionary's Simple English data and save it as a dictionary"
     task :prepare do
-      sh 'ruby evaluation/dictionary_generator.rb'
+      sh "RUBYOPT='--disable-did_you_mean' ruby evaluation/dictionary_generator.rb"
     end
   end
 
@@ -34,7 +37,7 @@ namespace :test do
       puts "\n"
     end
 
-    sh 'ruby evaluation/calculator.rb'
+    sh "RUBYOPT='--disable-did_you_mean' ruby evaluation/calculator.rb"
   end
 end
 
@@ -42,29 +45,29 @@ namespace :benchmark do
   namespace :ips do
     desc "Measure performance of the gem's Jaro distance implementation"
     task :jaro do
-      sh "ruby benchmark/jaro_winkler/speed.rb"
+      sh "RUBYOPT='--disable-did_you_mean' ruby benchmark/jaro_winkler/speed.rb"
     end
 
     desc "Benchmark performance of the gem's Levenshtein distance implementation"
     task :levenshtein do
-      sh "ruby benchmark/levenshtein/speed.rb"
+      sh "RUBYOPT='--disable-did_you_mean' ruby benchmark/levenshtein/speed.rb"
     end
   end
 
   desc "Benchmark memory usage in the gem's spell checker"
   task :memory do
-    sh "ruby benchmark/memory_usage.rb"
+    sh "RUBYOPT='--disable-did_you_mean' ruby benchmark/memory_usage.rb"
   end
 
   namespace :memory do
     desc "Benchmark memory usage in the gem's Jaro distance implementation"
     task :jaro do
-      sh "ruby benchmark/jaro_winkler/memory_usage.rb"
+      sh "RUBYOPT='--disable-did_you_mean' ruby benchmark/jaro_winkler/memory_usage.rb"
     end
 
     desc "Benchmark memory usage in the gem's Levenshtein distance implementation"
     task :levenshtein do
-      sh "ruby benchmark/levenshtein/memory_usage.rb"
+      sh "RUBYOPT='--disable-did_you_mean' ruby benchmark/levenshtein/memory_usage.rb"
     end
   end
 end

data/benchmark/require_path_checker.rb

@@ -0,0 +1,47 @@
+# frozen-string-literal: true
+#
+# Run the following command to run this script:
+#
+#   $ ruby --disable-did_you_mean benchmark/require_path_checker.rb
+#
+
+require_relative '../lib/did_you_mean/spell_checkers/require_path_checker'
+
+require 'benchmark/ips'
+
+Benchmark.ips do |x|
+  x.config(time: 10, warmup: 10)
+
+  exception_with_slash = begin
+                           require 'net/htto'
+                         rescue LoadError => error
+                           error
+                         end
+
+  exception_without_slash = begin
+                              require 'net-http'
+                            rescue LoadError => error
+                              error
+                            end
+
+  checker_for_path = DidYouMean::RequirePathChecker.new(exception_with_slash)
+  checker_for_file = DidYouMean::RequirePathChecker.new(exception_without_slash)
+
+  x.report "original (with a /)" do
+    checker_for_path.corrections
+  end
+
+  x.report "original (without /)" do
+    checker_for_file.corrections
+  end
+
+  #x.report "proposed (with a /)" do
+  #  checker_for_path.experiment
+  #end
+  #
+  #x.report "proposed (without /)" do
+  #  checker_for_file.experiment
+  #end
+
+  x.compare!
+end

data/lib/did_you_mean.rb

@@ -6,6 +6,7 @@ require_relative 'did_you_mean/spell_checkers/name_error_checkers'
 require_relative 'did_you_mean/spell_checkers/method_name_checker'
 require_relative 'did_you_mean/spell_checkers/key_error_checker'
 require_relative 'did_you_mean/spell_checkers/null_checker'
+require_relative 'did_you_mean/spell_checkers/require_path_checker'
 require_relative 'did_you_mean/formatters/plain_formatter'
 require_relative 'did_you_mean/tree_spell_checker'
 
@@ -95,8 +96,9 @@ module DidYouMean
   correct_error NameError, NameErrorCheckers
   correct_error KeyError, KeyErrorChecker
   correct_error NoMethodError, MethodNameChecker
+  correct_error LoadError, RequirePathChecker if RUBY_VERSION >= '2.8.0'
 
-  # Returns the currenctly set formatter. By default, it is set to +DidYouMean::Formatter+.
+  # Returns the currently set formatter. By default, it is set to +DidYouMean::Formatter+.
   def self.formatter
     @@formatter
   end

data/lib/did_you_mean/spell_checkers/method_name_checker.rb

@@ -43,7 +43,12 @@ module DidYouMean
     end
 
     def corrections
-      @corrections ||= SpellChecker.new(dictionary: RB_RESERVED_WORDS + method_names).correct(method_name) - names_to_exclude
+      @corrections ||= begin
+                         dictionary = method_names
+                         dictionary = RB_RESERVED_WORDS + dictionary if @private_call
+
+                         SpellChecker.new(dictionary: dictionary).correct(method_name) - names_to_exclude
+                       end
     end
 
     def method_names

data/lib/did_you_mean/spell_checkers/require_path_checker.rb

@@ -0,0 +1,35 @@
+# frozen-string-literal: true
+
+require_relative "../spell_checker"
+require_relative "../tree_spell_checker"
+
+module DidYouMean
+  class RequirePathChecker
+    attr_reader :path
+
+    INITIAL_LOAD_PATH = $LOAD_PATH.dup.freeze
+    ENV_SPECIFIC_EXT  = ".#{RbConfig::CONFIG["DLEXT"]}"
+
+    private_constant :INITIAL_LOAD_PATH, :ENV_SPECIFIC_EXT
+
+    def self.requireables
+      @requireables ||= INITIAL_LOAD_PATH
+                          .flat_map {|path| Dir.glob("**/???*{.rb,#{ENV_SPECIFIC_EXT}}", base: path) }
+                          .map {|path| path.chomp!(".rb") || path.chomp!(ENV_SPECIFIC_EXT) }
+    end
+
+    def initialize(exception)
+      @path = exception.path
+    end
+
+    def corrections
+      @corrections ||= begin
+                         threshold     = path.size * 2
+                         dictionary    = self.class.requireables.reject {|str| str.size >= threshold }
+                         spell_checker = path.include?("/") ? TreeSpellChecker : SpellChecker
+
+                         spell_checker.new(dictionary: dictionary).correct(path).uniq
+                       end
+    end
+  end
+end

data/lib/did_you_mean/tree_spell_checker.rb

@@ -1,137 +1,109 @@
+# frozen_string_literal: true
+
 module DidYouMean
   # spell checker for a dictionary that has a tree
   # structure, see doc/tree_spell_checker_api.md
   class TreeSpellChecker
-    attr_reader :dictionary, :dimensions, :separator, :augment
+    attr_reader :dictionary, :separator, :augment
 
     def initialize(dictionary:, separator: '/', augment: nil)
       @dictionary = dictionary
       @separator = separator
       @augment = augment
-      @dimensions = parse_dimensions
     end
 
     def correct(input)
-      plausibles = plausible_dimensions input
-      return no_idea(input) if plausibles.empty?
-      suggestions = find_suggestions input, plausibles
-      return no_idea(input) if suggestions.empty?
-      suggestions
-    end
+      plausibles = plausible_dimensions(input)
+      return fall_back_to_normal_spell_check(input) if plausibles.empty?
 
-    private
+      suggestions = find_suggestions(input, plausibles)
+      return fall_back_to_normal_spell_check(input) if suggestions.empty?
 
-    def parse_dimensions
-      ParseDimensions.new(dictionary, separator).call
+      suggestions
     end
 
-    def find_suggestions(input, plausibles)
-      states = plausibles[0].product(*plausibles[1..-1])
-      paths = possible_paths states
-      leaf = input.split(separator).last
-      ideas = find_ideas(paths, leaf)
-      ideas.compact.flatten
+    def dictionary_without_leaves
+      @dictionary_without_leaves ||= dictionary.map { |word| word.split(separator)[0..-2] }.uniq
     end
 
-    def no_idea(input)
-      return [] unless augment
-      ::DidYouMean::SpellChecker.new(dictionary: dictionary).correct(input)
+    def tree_depth
+      @tree_depth ||= dictionary_without_leaves.max { |a, b| a.size <=> b.size }.size
     end
 
-    def find_ideas(paths, leaf)
-      paths.map do |path|
-        names = find_leaves(path)
-        ideas = CorrectElement.new.call names, leaf
-        ideas_to_paths ideas, leaf, names, path
-      end
+    def dimensions
+      @dimensions ||= tree_depth.times.map do |index|
+                        dictionary_without_leaves.map { |element| element[index] }.compact.uniq
+                      end
     end
 
-    def ideas_to_paths(ideas, leaf, names, path)
-      return nil if ideas.empty?
-      return [path + separator + leaf] if names.include? leaf
-      ideas.map { |str| path + separator + str }
+    def find_leaves(path)
+      path_with_separator = "#{path}#{separator}"
+
+      dictionary
+        .select {|str| str.include?(path_with_separator) }
+        .map {|str| str.gsub(path_with_separator, '') }
     end
 
-    def find_leaves(path)
-      dictionary.map do |str|
-        next unless str.include? "#{path}#{separator}"
-        str.gsub("#{path}#{separator}", '')
-      end.compact
+    def plausible_dimensions(input)
+      input.split(separator)[0..-2]
+        .map
+        .with_index { |element, index| correct_element(dimensions[index], element) if dimensions[index] }
+        .compact
     end
 
     def possible_paths(states)
-      states.map do |state|
-        state.join separator
-      end
+      states.map { |state| state.join(separator) }
     end
 
-    def plausible_dimensions(input)
-      elements = input.split(separator)[0..-2]
-      elements.each_with_index.map do |element, i|
-        next if dimensions[i].nil?
-        CorrectElement.new.call dimensions[i], element
-      end.compact
-    end
-  end
+    private
 
-  # parses the elements in each dimension
-  class ParseDimensions
-    def initialize(dictionary, separator)
-      @dictionary = dictionary
-      @separator = separator
+    def find_suggestions(input, plausibles)
+      states = plausibles[0].product(*plausibles[1..-1])
+      paths  = possible_paths(states)
+      leaf   = input.split(separator).last
+
+      find_ideas(paths, leaf)
     end
 
-    def call
-      leafless = remove_leaves
-      dimensions = find_elements leafless
-      dimensions.map do |elements|
-        elements.to_set.to_a
-      end
+    def fall_back_to_normal_spell_check(input)
+      return [] unless augment
+
+      ::DidYouMean::SpellChecker.new(dictionary: dictionary).correct(input)
     end
 
-    private
+    def find_ideas(paths, leaf)
+      paths.flat_map do |path|
+        names = find_leaves(path)
+        ideas = correct_element(names, leaf)
 
-    def remove_leaves
-      dictionary.map do |a|
-        elements = a.split(separator)
-        elements[0..-2]
-      end.to_set.to_a
+        ideas_to_paths(ideas, leaf, names, path)
+      end.compact
     end
 
-    def find_elements(leafless)
-      max_elements = leafless.map(&:size).max
-      dimensions = Array.new(max_elements) { [] }
-      (0...max_elements).each do |i|
-        leafless.each do |elements|
-          dimensions[i] << elements[i] unless elements[i].nil?
-        end
+    def ideas_to_paths(ideas, leaf, names, path)
+      if ideas.empty?
+        nil
+      elsif names.include?(leaf)
+        ["#{path}#{separator}#{leaf}"]
+      else
+        ideas.map {|str| "#{path}#{separator}#{str}" }
       end
-      dimensions
     end
 
-    attr_reader :dictionary, :separator
-  end
+    def correct_element(names, element)
+      return names if names.size == 1
 
-  # identifies the elements close to element
-  class CorrectElement
-    def initialize
-    end
+      str = normalize(element)
 
-    def call(names, element)
-      return names if names.size == 1
-      str = normalize element
-      return [str] if names.include? str
-      checker = ::DidYouMean::SpellChecker.new(dictionary: names)
-      checker.correct(str)
-    end
+      return [str] if names.include?(str)
 
-    private
+      ::DidYouMean::SpellChecker.new(dictionary: names).correct(str)
+    end
 
-    def normalize(leaf)
-      str = leaf.dup
+    def normalize(str)
       str.downcase!
-      return str unless str.include? '@'
-      str.tr!('@', '  ')
+      str.tr!('@', ' ') if str.include?('@')
+      str
     end
   end
 end

data/lib/did_you_mean/version.rb

@@ -1,3 +1,3 @@
 module DidYouMean
-  VERSION = "1.4.0"
+  VERSION = "1.5.0"
 end

data/test/fixtures/book.rb

@@ -1,4 +1,4 @@
 class Book
-  class Cover
+  class Spine
   end
 end

data/test/spell_checking/test_class_name_check.rb

@@ -66,11 +66,13 @@ class ClassNameCheckTest < Test::Unit::TestCase
   end
 
   def test_does_not_suggest_user_input
-    error = assert_raise(NameError) { ::Book::Cover }
+    Book.send(:remove_const, :Spine) if Book.constants.include?(:Spine)
+
+    error = assert_raise(NameError) { ::Book::Spine }
 
     # 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
-    # attemps to find a possible suggestion. The manual require here simulates
+    # attempts to find a possible suggestion. The manual require here simulates
     # a race condition a single test.
     require_relative '../fixtures/book'
 

data/test/spell_checking/test_method_name_check.rb

@@ -137,4 +137,11 @@ class MethodNameCheckTest < Test::Unit::TestCase
     assert_correction :yield, error.corrections
     assert_match "Did you mean?  yield", error.to_s
   end
+
+  def test_does_not_suggest_yield
+    error = assert_raise(NoMethodError) { 1.yeild }
+
+    assert_correction [], error.corrections
+    assert_not_match(/Did you mean\? +yield/, error.to_s)
+  end if RUBY_ENGINE != "jruby"
 end

data/test/spell_checking/test_require_path_check.rb

@@ -0,0 +1,32 @@
+require_relative '../helper'
+
+return if !(RUBY_VERSION >= '2.8.0')
+
+class RequirePathCheckTest < Test::Unit::TestCase
+  include DidYouMean::TestHelper
+
+  def test_load_error_from_require_has_suggestions
+    error = assert_raise LoadError do
+              require 'open_struct'
+            end
+
+    assert_correction 'ostruct', error.corrections
+    assert_match "Did you mean?  ostruct", error.to_s
+  end
+
+  def test_load_error_from_require_for_nested_files_has_suggestions
+    error = assert_raise LoadError do
+              require 'net/htt'
+            end
+
+    assert_correction 'net/http', error.corrections
+    assert_match "Did you mean?  net/http", error.to_s
+
+    error = assert_raise LoadError do
+              require 'net-http'
+            end
+
+    assert_correction ['net/http', 'net/https'], error.corrections
+    assert_match "Did you mean?  net/http", error.to_s
+  end
+end

data/test/test_tree_spell_checker.rb

@@ -1,11 +1,12 @@
-require 'set'
-require 'yaml'
+# frozen_string_literal: true
 
-require_relative './helper'
+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__))
+  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 =
@@ -20,154 +21,150 @@ class TreeSpellCheckerTest < Test::Unit::TestCase
         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)
+    @test_str = "spek/modeks/confirns/viken_spec.rb"
+    @tree_spell_checker = 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
+    assert_tree_spell "test/verbose_formatter_test.rb",
+                      input: "btets/cverbose_formatter_etst.rb suggestions",
+                      dictionary: MINI_DIRECTORIES
   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
+    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
-    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'
+    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
-    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
+    [
+      %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
-  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']
-    ]
+      %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 special_words_mini
+  def test_special_words_rspec
     [
-     ['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']
-  ]
+      %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
-    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
+    assert_tree_spell "test/spell_checker_test.rb", input: "test/spell_checker_test.r", dictionary: MINI_DIRECTORIES
   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
+    assert_tree_spell [], input: "testspell_checker_test.rb", dictionary: MINI_DIRECTORIES
   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
+    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
-    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
+    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
-    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
+    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
-    correct_input = 'spec/models/concerns/vixenus_spec.rb'
-    suggestions = @tsp.correct correct_input
-    assert_equal suggestions.first, correct_input
+    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
-    path = 'spec/modals/confirms'
-    names = @tsp.send(:find_leaves, path)
-    assert_equal names.to_set, %w(abcd_spec.rb efgh_spec.rb).to_set
+    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'].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
+    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 = @tsp.send(:plausible_dimensions, @test_str)
-    assert_equal suggestions, [["spec"], ["models", "modals"], ["confirms", "concerns"]]
+    suggestions = @tree_spell_checker.plausible_dimensions(@test_str)
+
+    assert_equal [["spec"], %w[models modals], %w[confirms concerns]], suggestions
   end
 
   def test_parses_dictionary
-    states = @tsp.send(:parse_dimensions)
-    assert_equal states, [["spec"], ["models", "modals", "controllers"], ["concerns", "confirms"]]
+    states = @tree_spell_checker.dimensions
+
+    assert_equal [["spec"], %w[models modals controllers], %w[concerns confirms]], states
   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']]
+    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/test_verbose_formatter.rb

@@ -3,6 +3,8 @@ require_relative './helper'
 class VerboseFormatterTest < Test::Unit::TestCase
   def setup
     require_relative File.join(DidYouMean::TestHelper.root, 'verbose')
+
+    DidYouMean.formatter = DidYouMean::VerboseFormatter.new
   end
 
   def teardown

data/test/tree_spell/human_typo.rb

@@ -4,6 +4,9 @@ module TreeSpell
   # 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
@@ -15,7 +18,7 @@ module TreeSpell
       @word = input.dup
       i_place = initialize_i_place
       loop do
-        action = action_type
+        action = ACTION_TYPES.sample
         @word = make_change action, i_place
         @len = word.length
         i_place += exponential
@@ -41,40 +44,17 @@ module TreeSpell
       (rand / (lambda / 2)).to_i
     end
 
-    def rand_char
-      popular_chars =  alphabetic_characters + special_characters
-      n = popular_chars.length
-      popular_chars[rand(n)]
-    end
-
-    def alphabetic_characters
-      ('a'..'z').to_a.join + ('A'..'Z').to_a.join
-    end
-
-    def special_characters
-      '?<>,.!`+=-_":;@#$%^&*()'
-    end
-
-    def toss
-      return +1 if rand >= 0.5
-      -1
-    end
-
-    def action_type
-      [:insert, :transpose, :delete, :substitute][rand(4)]
-    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, rand_char)
+        cw.insertion(i_place, POPULAR_CHARS.sample)
       when :substitute
-        cw.substitution(i_place, rand_char)
+        cw.substitution(i_place, POPULAR_CHARS.sample)
       when :transpose
-        cw.transposition(i_place, toss)
+        cw.transposition(i_place, rand >= 0.5 ? +1 : -1)
       end
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: did_you_mean
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Yuki Nishijima
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-12-24 00:00:00.000000000 Z
+date: 2020-12-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -44,6 +44,7 @@ files:
 - benchmark/levenshtein/memory_usage.rb
 - benchmark/levenshtein/speed.rb
 - benchmark/memory_usage.rb
+- benchmark/require_path_checker.rb
 - benchmark/speed.yml
 - did_you_mean.gemspec
 - documentation/CHANGELOG.md.erb
@@ -54,8 +55,6 @@ files:
 - lib/did_you_mean.rb
 - lib/did_you_mean/core_ext/name_error.rb
 - lib/did_you_mean/experimental.rb
-- lib/did_you_mean/experimental/initializer_name_correction.rb
-- lib/did_you_mean/experimental/ivar_name_correction.rb
 - lib/did_you_mean/formatters/plain_formatter.rb
 - lib/did_you_mean/formatters/verbose_formatter.rb
 - lib/did_you_mean/jaro_winkler.rb
@@ -67,6 +66,7 @@ files:
 - lib/did_you_mean/spell_checkers/name_error_checkers/class_name_checker.rb
 - lib/did_you_mean/spell_checkers/name_error_checkers/variable_name_checker.rb
 - lib/did_you_mean/spell_checkers/null_checker.rb
+- lib/did_you_mean/spell_checkers/require_path_checker.rb
 - lib/did_you_mean/tree_spell_checker.rb
 - lib/did_you_mean/verbose.rb
 - lib/did_you_mean/version.rb
@@ -79,6 +79,7 @@ files:
 - test/spell_checking/test_class_name_check.rb
 - test/spell_checking/test_key_name_check.rb
 - test/spell_checking/test_method_name_check.rb
+- test/spell_checking/test_require_path_check.rb
 - test/spell_checking/test_uncorrectable_name_check.rb
 - test/spell_checking/test_variable_name_check.rb
 - test/test_spell_checker.rb
@@ -108,7 +109,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.3
 signing_key: 
 specification_version: 4
 summary: '"Did you mean?" experience in Ruby'
@@ -122,6 +123,7 @@ test_files:
 - test/spell_checking/test_class_name_check.rb
 - test/spell_checking/test_key_name_check.rb
 - test/spell_checking/test_method_name_check.rb
+- test/spell_checking/test_require_path_check.rb
 - test/spell_checking/test_uncorrectable_name_check.rb
 - test/spell_checking/test_variable_name_check.rb
 - test/test_spell_checker.rb

data/lib/did_you_mean/experimental/initializer_name_correction.rb

@@ -1,20 +0,0 @@
-# frozen-string-literal: true
-
-require_relative '../levenshtein'
-
-module DidYouMean
-  module Experimental
-    module InitializerNameCorrection
-      def method_added(name)
-        super
-
-        distance = Levenshtein.distance(name.to_s, 'initialize')
-        if distance != 0 && distance <= 2
-          warn "warning: #{name} might be misspelled, perhaps you meant initialize?"
-        end
-      end
-    end
-
-    ::Class.prepend(InitializerNameCorrection)
-  end
-end

data/lib/did_you_mean/experimental/ivar_name_correction.rb

@@ -1,76 +0,0 @@
-# frozen-string-literal: true
-
-require_relative '../../did_you_mean'
-
-module DidYouMean
-  module Experimental #:nodoc:
-    class IvarNameCheckerBuilder #:nodoc:
-      attr_reader :original_checker
-
-      def initialize(original_checker) #:nodoc:
-        @original_checker = original_checker
-      end
-
-      def new(no_method_error) #:nodoc:
-        IvarNameChecker.new(no_method_error, original_checker: @original_checker)
-      end
-    end
-
-    class IvarNameChecker #:nodoc:
-      REPLS = {
-        "(irb)" => -> { Readline::HISTORY.to_a.last }
-      }
-
-      TRACE = TracePoint.trace(:raise) do |tp|
-        e = tp.raised_exception
-
-        if SPELL_CHECKERS.include?(e.class.to_s) && !e.instance_variable_defined?(:@frame_binding)
-          e.instance_variable_set(:@frame_binding, tp.binding)
-        end
-      end
-
-      attr_reader :original_checker
-
-      def initialize(no_method_error, original_checker: )
-        @original_checker = original_checker.new(no_method_error)
-
-        @location   = no_method_error.backtrace_locations.first
-        @ivar_names = no_method_error.frame_binding.receiver.instance_variables
-
-        no_method_error.remove_instance_variable(:@frame_binding)
-      end
-
-      def corrections
-        original_checker.corrections + ivar_name_corrections
-      end
-
-      def ivar_name_corrections
-        @ivar_name_corrections ||= SpellChecker.new(dictionary: @ivar_names).correct(receiver_name.to_s)
-      end
-
-      private
-
-      def receiver_name
-        return unless @original_checker.receiver.nil?
-
-        abs_path = @location.absolute_path
-        lineno   = @location.lineno
-
-        /@(\w+)*\.#{@original_checker.method_name}/ =~ line(abs_path, lineno).to_s && $1
-      end
-
-      def line(abs_path, lineno)
-        if REPLS[abs_path]
-          REPLS[abs_path].call
-        elsif File.exist?(abs_path)
-          File.open(abs_path) do |file|
-            file.detect { file.lineno == lineno }
-          end
-        end
-      end
-    end
-  end
-
-  NameError.send(:attr, :frame_binding)
-  SPELL_CHECKERS['NoMethodError'] = Experimental::IvarNameCheckerBuilder.new(SPELL_CHECKERS['NoMethodError'])
-end