did_you_mean 1.2.1 → 1.5.0

data/lib/did_you_mean/spell_checkers/key_error_checker.rb

@@ -1,4 +1,4 @@
-require "did_you_mean/spell_checker"
+require_relative "../spell_checker"
 
 module DidYouMean
   class KeyErrorChecker
@@ -8,7 +8,13 @@ module DidYouMean
     end
 
     def corrections
-      @corrections ||= SpellChecker.new(dictionary: @keys).correct(@key).map(&:inspect)
+      @corrections ||= exact_matches.empty? ? SpellChecker.new(dictionary: @keys).correct(@key).map(&:inspect) : exact_matches
+    end
+
+    private
+
+    def exact_matches
+      @exact_matches ||= @keys.select { |word| @key == word.to_s }.map(&:inspect)
     end
   end
 end

data/lib/did_you_mean/spell_checkers/method_name_checker.rb

@@ -1,4 +1,4 @@
-require "did_you_mean/spell_checker"
+require_relative "../spell_checker"
 
 module DidYouMean
   class MethodNameChecker
@@ -7,6 +7,35 @@ module DidYouMean
     NAMES_TO_EXCLUDE = { NilClass => nil.methods }
     NAMES_TO_EXCLUDE.default = []
 
+    # +MethodNameChecker::RB_RESERVED_WORDS+ is the list of reserved words in
+    # Ruby that take an argument. Unlike
+    # +VariableNameChecker::RB_RESERVED_WORDS+, these reserved words require
+    # an argument, and a +NoMethodError+ is raised due to the presence of the
+    # argument.
+    #
+    # The +MethodNameChecker+ will use this list to suggest a reversed word if
+    # a +NoMethodError+ is raised and found closest matches.
+    #
+    # Also see +VariableNameChecker::RB_RESERVED_WORDS+.
+    RB_RESERVED_WORDS = %i(
+      alias
+      case
+      def
+      defined?
+      elsif
+      end
+      ensure
+      for
+      rescue
+      super
+      undef
+      unless
+      until
+      when
+      while
+      yield
+    )
+
     def initialize(exception)
       @method_name  = exception.name
       @receiver     = exception.receiver
@@ -14,14 +43,27 @@ module DidYouMean
     end
 
     def corrections
-      @corrections ||= SpellChecker.new(dictionary: method_names).correct(method_name) - NAMES_TO_EXCLUDE[@receiver.class]
+      @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
-      method_names = receiver.methods + receiver.singleton_methods
-      method_names += receiver.private_methods if @private_call
-      method_names.uniq!
-      method_names
+      if Object === receiver
+        method_names = receiver.methods + receiver.singleton_methods
+        method_names += receiver.private_methods if @private_call
+        method_names.uniq!
+        method_names
+      else
+        []
+      end
+    end
+
+    def names_to_exclude
+      Object === receiver ? NAMES_TO_EXCLUDE[receiver.class] : []
     end
   end
 end

data/lib/did_you_mean/spell_checkers/name_error_checkers.rb

@@ -1,5 +1,5 @@
-require 'did_you_mean/spell_checkers/name_error_checkers/class_name_checker'
-require 'did_you_mean/spell_checkers/name_error_checkers/variable_name_checker'
+require_relative 'name_error_checkers/class_name_checker'
+require_relative 'name_error_checkers/variable_name_checker'
 
 module DidYouMean
   class << (NameErrorCheckers = Object.new)

data/lib/did_you_mean/spell_checkers/name_error_checkers/class_name_checker.rb

@@ -1,6 +1,6 @@
 # frozen-string-literal: true
-require 'delegate'
-require "did_you_mean/spell_checker"
+
+require_relative "../../spell_checker"
 
 module DidYouMean
   class ClassNameChecker
@@ -31,16 +31,16 @@ module DidYouMean
       end.uniq
     end
 
-    class ClassName < SimpleDelegator
+    class ClassName < String
       attr :namespace
 
       def initialize(name, namespace = '')
-        super(name)
+        super(name.to_s)
         @namespace = namespace
       end
 
       def full_name
-        self.class.new("#{namespace}#{__getobj__}")
+        self.class.new("#{namespace}#{self}")
       end
     end
 

data/lib/did_you_mean/spell_checkers/name_error_checkers/variable_name_checker.rb

@@ -1,14 +1,66 @@
 # frozen-string-literal: true
 
-require "did_you_mean/spell_checker"
+require_relative "../../spell_checker"
 
 module DidYouMean
   class VariableNameChecker
     attr_reader :name, :method_names, :lvar_names, :ivar_names, :cvar_names
 
-    NAMES_TO_EXCLUDE = { 'foo' => [:fork] }
+    NAMES_TO_EXCLUDE = { 'foo' => [:fork, :for] }
     NAMES_TO_EXCLUDE.default = []
-    RB_PREDEFINED_OBJECTS = [:false, :true, :nil]
+
+    # +VariableNameChecker::RB_RESERVED_WORDS+ is the list of all reserved
+    # words in Ruby. They could be declared like methods are, and a typo would
+    # cause Ruby to raise a +NameError+ because of the way they are declared.
+    #
+    # The +:VariableNameChecker+ will use this list to suggest a reversed word
+    # if a +NameError+ is raised and found closest matches, excluding:
+    #
+    #   * +do+
+    #   * +if+
+    #   * +in+
+    #   * +or+
+    #
+    # Also see +MethodNameChecker::RB_RESERVED_WORDS+.
+    RB_RESERVED_WORDS = %i(
+      BEGIN
+      END
+      alias
+      and
+      begin
+      break
+      case
+      class
+      def
+      defined?
+      else
+      elsif
+      end
+      ensure
+      false
+      for
+      module
+      next
+      nil
+      not
+      redo
+      rescue
+      retry
+      return
+      self
+      super
+      then
+      true
+      undef
+      unless
+      until
+      when
+      while
+      yield
+      __LINE__
+      __FILE__
+      __ENCODING__
+    )
 
     def initialize(exception)
       @name       = exception.name.to_s.tr("@", "")
@@ -23,7 +75,7 @@ module DidYouMean
 
     def corrections
       @corrections ||= SpellChecker
-                     .new(dictionary: (RB_PREDEFINED_OBJECTS + lvar_names + method_names + ivar_names + cvar_names))
+                     .new(dictionary: (RB_RESERVED_WORDS + lvar_names + method_names + ivar_names + cvar_names))
                      .correct(name) - NAMES_TO_EXCLUDE[@name]
     end
   end

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

@@ -0,0 +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, :separator, :augment
+
+    def initialize(dictionary:, separator: '/', augment: nil)
+      @dictionary = dictionary
+      @separator = separator
+      @augment = augment
+    end
+
+    def correct(input)
+      plausibles = plausible_dimensions(input)
+      return fall_back_to_normal_spell_check(input) if plausibles.empty?
+
+      suggestions = find_suggestions(input, plausibles)
+      return fall_back_to_normal_spell_check(input) if suggestions.empty?
+
+      suggestions
+    end
+
+    def dictionary_without_leaves
+      @dictionary_without_leaves ||= dictionary.map { |word| word.split(separator)[0..-2] }.uniq
+    end
+
+    def tree_depth
+      @tree_depth ||= dictionary_without_leaves.max { |a, b| a.size <=> b.size }.size
+    end
+
+    def dimensions
+      @dimensions ||= tree_depth.times.map do |index|
+                        dictionary_without_leaves.map { |element| element[index] }.compact.uniq
+                      end
+    end
+
+    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 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 { |state| state.join(separator) }
+    end
+
+    private
+
+    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 fall_back_to_normal_spell_check(input)
+      return [] unless augment
+
+      ::DidYouMean::SpellChecker.new(dictionary: dictionary).correct(input)
+    end
+
+    def find_ideas(paths, leaf)
+      paths.flat_map do |path|
+        names = find_leaves(path)
+        ideas = correct_element(names, leaf)
+
+        ideas_to_paths(ideas, leaf, names, path)
+      end.compact
+    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
+    end
+
+    def correct_element(names, element)
+      return names if names.size == 1
+
+      str = normalize(element)
+
+      return [str] if names.include?(str)
+
+      ::DidYouMean::SpellChecker.new(dictionary: names).correct(str)
+    end
+
+    def normalize(str)
+      str.downcase!
+      str.tr!('@', ' ') if str.include?('@')
+      str
+    end
+  end
+end

data/lib/did_you_mean/verbose.rb

@@ -1,4 +1,4 @@
-require 'did_you_mean'
-require 'did_you_mean/formatters/verbose_formatter'
+require_relative '../did_you_mean'
+require_relative 'formatters/verbose_formatter'
 
 DidYouMean.formatter = DidYouMean::VerboseFormatter.new

data/lib/did_you_mean/version.rb

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

data/test/core_ext/test_name_error_extension.rb

@@ -0,0 +1,48 @@
+require_relative '../helper'
+
+class NameErrorExtensionTest < Test::Unit::TestCase
+  SPELL_CHECKERS = DidYouMean::SPELL_CHECKERS
+
+  class TestSpellChecker
+    def initialize(*); end
+    def corrections; ["does_exist"]; end
+  end
+
+  def setup
+    @org, SPELL_CHECKERS['NameError'] = SPELL_CHECKERS['NameError'], TestSpellChecker
+
+    @error = assert_raise(NameError){ doesnt_exist }
+  end
+
+  def teardown
+    SPELL_CHECKERS['NameError'] = @org
+  end
+
+  def test_message
+    assert_match(/Did you mean\?  does_exist/, @error.to_s)
+    assert_match(/Did you mean\?  does_exist/, @error.message)
+  end
+
+  def test_to_s_does_not_make_disruptive_changes_to_error_message
+    error = assert_raise(NameError) do
+      raise NameError, "uninitialized constant Object"
+    end
+
+    error.to_s
+    assert_equal 1, error.to_s.scan("Did you mean?").count
+  end
+
+  def test_correctable_error_objects_are_dumpable
+    error =
+      begin
+        Dir.chdir(__dir__) { File.open('test_name_error_extension.rb') { |f| f.sizee } }
+      rescue NoMethodError => e
+        e
+      end
+
+    error.to_s
+
+    assert_equal "undefined method `sizee' for #<File:test_name_error_extension.rb (closed)>",
+                 Marshal.load(Marshal.dump(error)).original_message
+  end
+end

data/test/edit_distance/{jaro_winkler_test.rb → test_jaro_winkler.rb}

@@ -1,4 +1,4 @@
-require 'test_helper'
+require_relative '../helper'
 
 # These tests were originally written by Jian Weihang (簡煒航) as part of his work
 # on the jaro_winkler gem. The original code could be found here:
@@ -6,7 +6,7 @@ require 'test_helper'
 #
 # Copyright (c) 2014 Jian Weihang
 
-class JaroWinklerTest < Minitest::Test
+class JaroWinklerTest < Test::Unit::TestCase
   def test_jaro_winkler_distance
     assert_distance 0.9667, 'henka',      'henkan'
     assert_distance 1.0,    'al',         'al'

data/test/fixtures/book.rb

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

data/test/fixtures/mini_dir.yml

@@ -0,0 +1,15 @@
+---
+- test/core_ext/name_error_extension_test.rb
+- test/edit_distance/jaro_winkler_test.rb
+- test/fixtures/book.rb
+- test/spell_checker_test.rb
+- test/spell_checking/class_name_check_test.rb
+- test/spell_checking/key_name_check_test.rb
+- test/spell_checking/method_name_check_test.rb
+- test/spell_checking/uncorrectable_name_check_test.rb
+- test/spell_checking/variable_name_check_test.rb
+- test/test_helper.rb
+- test/tree_spell_checker_test.rb
+- test/tree_spell_explore_test.rb
+- test/tree_spell_human_typo_test.rb
+- test/verbose_formatter_test.rb