diff options
Diffstat (limited to 'lib/did_you_mean')
20 files changed, 777 insertions, 0 deletions
diff --git a/lib/did_you_mean/core_ext/name_error.rb b/lib/did_you_mean/core_ext/name_error.rb new file mode 100644 index 0000000000..8c170c4b90 --- /dev/null +++ b/lib/did_you_mean/core_ext/name_error.rb @@ -0,0 +1,57 @@ +module DidYouMean + module Correctable + if Exception.method_defined?(:detailed_message) + # just for compatibility + def original_message + # we cannot use alias here because + to_s + end + + def detailed_message(highlight: true, did_you_mean: true, **) + msg = super.dup + + return msg unless did_you_mean + + suggestion = DidYouMean.formatter.message_for(corrections) + + if highlight + suggestion = suggestion.gsub(/.+/) { "\e[1m" + $& + "\e[m" } + end + + msg << suggestion + msg + rescue + super + end + else + SKIP_TO_S_FOR_SUPER_LOOKUP = true + private_constant :SKIP_TO_S_FOR_SUPER_LOOKUP + + def original_message + meth = method(:to_s) + while meth.owner.const_defined?(:SKIP_TO_S_FOR_SUPER_LOOKUP) + meth = meth.super_method + end + meth.call + end + + def to_s + msg = super.dup + suggestion = DidYouMean.formatter.message_for(corrections) + + msg << suggestion if !msg.include?(suggestion) + msg + rescue + super + end + end + + def corrections + @corrections ||= spell_checker.corrections + end + + def spell_checker + DidYouMean.spell_checkers[self.class.to_s].new(self) + end + end +end diff --git a/lib/did_you_mean/did_you_mean.gemspec b/lib/did_you_mean/did_you_mean.gemspec new file mode 100644 index 0000000000..be4ac76b4b --- /dev/null +++ b/lib/did_you_mean/did_you_mean.gemspec @@ -0,0 +1,25 @@ +# coding: utf-8 +lib = File.expand_path('../lib', __FILE__) +$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib) +begin + require_relative "lib/did_you_mean/version" +rescue LoadError # Fallback to load version file in ruby core repository + require_relative "version" +end + +Gem::Specification.new do |spec| + spec.name = "did_you_mean" + spec.version = DidYouMean::VERSION + spec.authors = ["Yuki Nishijima"] + spec.email = ["mail@yukinishijima.net"] + spec.summary = '"Did you mean?" experience in Ruby' + spec.description = 'The gem that has been saving people from typos since 2014.' + spec.homepage = "https://github.com/ruby/did_you_mean" + spec.license = "MIT" + + spec.files = `git ls-files`.split($/).reject{|path| path.start_with?('evaluation/') } + spec.test_files = spec.files.grep(%r{^(test)/}) + spec.require_paths = ["lib"] + + spec.required_ruby_version = '>= 2.5.0' +end diff --git a/lib/did_you_mean/experimental.rb b/lib/did_you_mean/experimental.rb new file mode 100644 index 0000000000..f8e37e4532 --- /dev/null +++ b/lib/did_you_mean/experimental.rb @@ -0,0 +1,2 @@ +warn "Experimental features in the did_you_mean gem has been removed " \ + "and `require \"did_you_mean/experimental\"' has no effect." diff --git a/lib/did_you_mean/formatter.rb b/lib/did_you_mean/formatter.rb new file mode 100644 index 0000000000..c43748f707 --- /dev/null +++ b/lib/did_you_mean/formatter.rb @@ -0,0 +1,44 @@ +# frozen-string-literal: true + +module DidYouMean + # The +DidYouMean::Formatter+ is the basic, default formatter for the + # gem. The formatter responds to the +message_for+ method and it returns a + # human readable string. + class Formatter + + # Returns a human readable string that contains +corrections+. This + # formatter is designed to be less verbose to not take too much screen + # space while being helpful enough to the user. + # + # @example + # + # formatter = DidYouMean::Formatter.new + # + # # displays suggestions in two lines with the leading empty line + # puts formatter.message_for(["methods", "method"]) + # + # Did you mean? methods + # method + # # => nil + # + # # displays an empty line + # puts formatter.message_for([]) + # + # # => nil + # + def self.message_for(corrections) + corrections.empty? ? "" : "\nDid you mean? #{corrections.join("\n ")}" + end + + def message_for(corrections) + warn "The instance method #message_for has been deprecated. Please use the class method " \ + "DidYouMean::Formatter.message_for(...) instead." + + self.class.message_for(corrections) + end + end + + PlainFormatter = Formatter + + deprecate_constant :PlainFormatter +end diff --git a/lib/did_you_mean/formatters/plain_formatter.rb b/lib/did_you_mean/formatters/plain_formatter.rb new file mode 100644 index 0000000000..d669588e0f --- /dev/null +++ b/lib/did_you_mean/formatters/plain_formatter.rb @@ -0,0 +1,4 @@ +require_relative '../formatter' + +warn "`require 'did_you_mean/formatters/plain_formatter'` is deprecated. Please `require 'did_you_mean/formatter'` " \ + "instead." diff --git a/lib/did_you_mean/formatters/verbose_formatter.rb b/lib/did_you_mean/formatters/verbose_formatter.rb new file mode 100644 index 0000000000..f6623681f2 --- /dev/null +++ b/lib/did_you_mean/formatters/verbose_formatter.rb @@ -0,0 +1,10 @@ +# frozen-string-literal: true + +warn "`require 'did_you_mean/formatters/verbose_formatter'` is deprecated and falls back to the default formatter. " + +require_relative '../formatter' + +module DidYouMean + # For compatibility: + VerboseFormatter = Formatter +end diff --git a/lib/did_you_mean/jaro_winkler.rb b/lib/did_you_mean/jaro_winkler.rb new file mode 100644 index 0000000000..9a3e57f6d7 --- /dev/null +++ b/lib/did_you_mean/jaro_winkler.rb @@ -0,0 +1,84 @@ +module DidYouMean + module Jaro + module_function + + def distance(str1, str2) + str1, str2 = str2, str1 if str1.length > str2.length + length1, length2 = str1.length, str2.length + + m = 0.0 + t = 0.0 + range = length2 > 3 ? length2 / 2 - 1 : 0 + flags1 = 0 + flags2 = 0 + + # Avoid duplicating enumerable objects + str1_codepoints = str1.codepoints + str2_codepoints = str2.codepoints + + i = 0 + while i < length1 + last = i + range + j = (i >= range) ? i - range : 0 + + while j <= last + if flags2[j] == 0 && str1_codepoints[i] == str2_codepoints[j] + flags2 |= (1 << j) + flags1 |= (1 << i) + m += 1 + break + end + + j += 1 + end + + i += 1 + end + + k = i = 0 + while i < length1 + if flags1[i] != 0 + j = index = k + + k = while j < length2 + index = j + break(j + 1) if flags2[j] != 0 + + j += 1 + end + + t += 1 if str1_codepoints[i] != str2_codepoints[index] + end + + i += 1 + end + t = (t / 2).floor + + m == 0 ? 0 : (m / length1 + m / length2 + (m - t) / m) / 3 + end + end + + module JaroWinkler + WEIGHT = 0.1 + THRESHOLD = 0.7 + + module_function + + def distance(str1, str2) + jaro_distance = Jaro.distance(str1, str2) + + if jaro_distance > THRESHOLD + codepoints2 = str2.codepoints + prefix_bonus = 0 + + str1.each_codepoint do |char1| + char1 == codepoints2[prefix_bonus] && prefix_bonus < 4 ? prefix_bonus += 1 : break + end + + jaro_distance + (prefix_bonus * WEIGHT * (1 - jaro_distance)) + else + jaro_distance + end + end + end +end diff --git a/lib/did_you_mean/levenshtein.rb b/lib/did_you_mean/levenshtein.rb new file mode 100644 index 0000000000..098053470f --- /dev/null +++ b/lib/did_you_mean/levenshtein.rb @@ -0,0 +1,57 @@ +module DidYouMean + module Levenshtein # :nodoc: + # This code is based directly on the Text gem implementation + # Copyright (c) 2006-2013 Paul Battley, Michael Neumann, Tim Fletcher. + # + # Returns a value representing the "cost" of transforming str1 into str2 + def distance(str1, str2) + n = str1.length + m = str2.length + return m if n.zero? + return n if m.zero? + + d = (0..m).to_a + x = nil + + # to avoid duplicating an enumerable object, create it outside of the loop + str2_codepoints = str2.codepoints + + str1.each_codepoint.with_index(1) do |char1, i| + j = 0 + while j < m + cost = (char1 == str2_codepoints[j]) ? 0 : 1 + x = min3( + d[j+1] + 1, # insertion + i + 1, # deletion + d[j] + cost # substitution + ) + d[j] = i + i = x + + j += 1 + end + d[m] = x + end + + x + end + module_function :distance + + private + + # detects the minimum value out of three arguments. This method is + # faster than `[a, b, c].min` and puts less GC pressure. + # See https://github.com/ruby/did_you_mean/pull/1 for a performance + # benchmark. + def min3(a, b, c) + if a < b && a < c + a + elsif b < c + b + else + c + end + end + module_function :min3 + end +end diff --git a/lib/did_you_mean/spell_checker.rb b/lib/did_you_mean/spell_checker.rb new file mode 100644 index 0000000000..37da2fc7a6 --- /dev/null +++ b/lib/did_you_mean/spell_checker.rb @@ -0,0 +1,46 @@ +# frozen-string-literal: true + +require_relative "levenshtein" +require_relative "jaro_winkler" + +module DidYouMean + class SpellChecker + def initialize(dictionary:) + @dictionary = dictionary + end + + def correct(input) + normalized_input = normalize(input) + threshold = normalized_input.length > 3 ? 0.834 : 0.77 + + words = @dictionary.select { |word| JaroWinkler.distance(normalize(word), normalized_input) >= threshold } + words.reject! { |word| input.to_s == word.to_s } + words.sort_by! { |word| JaroWinkler.distance(word.to_s, normalized_input) } + words.reverse! + + # Correct mistypes + threshold = (normalized_input.length * 0.25).ceil + corrections = words.select { |c| Levenshtein.distance(normalize(c), normalized_input) <= threshold } + + # Correct misspells + if corrections.empty? + corrections = words.select do |word| + word = normalize(word) + length = normalized_input.length < word.length ? normalized_input.length : word.length + + Levenshtein.distance(word, normalized_input) < length + end.first(1) + end + + corrections + end + + private + + def normalize(str_or_symbol) #:nodoc: + str = str_or_symbol.to_s.downcase + str.tr!("@", "") + str + end + end +end diff --git a/lib/did_you_mean/spell_checkers/key_error_checker.rb b/lib/did_you_mean/spell_checkers/key_error_checker.rb new file mode 100644 index 0000000000..955bff1be6 --- /dev/null +++ b/lib/did_you_mean/spell_checkers/key_error_checker.rb @@ -0,0 +1,28 @@ +require_relative "../spell_checker" + +module DidYouMean + class KeyErrorChecker + def initialize(key_error) + @key = key_error.key + @keys = key_error.receiver.keys + end + + def corrections + @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 { |obj| format_object(obj) } + end + + def format_object(symbol_or_object) + if symbol_or_object.is_a?(Symbol) + ":#{symbol_or_object}" + else + symbol_or_object.to_s + end + end + end +end diff --git a/lib/did_you_mean/spell_checkers/method_name_checker.rb b/lib/did_you_mean/spell_checkers/method_name_checker.rb new file mode 100644 index 0000000000..b5cbbb5da6 --- /dev/null +++ b/lib/did_you_mean/spell_checkers/method_name_checker.rb @@ -0,0 +1,79 @@ +require_relative "../spell_checker" + +module DidYouMean + class MethodNameChecker + attr_reader :method_name, :receiver + + NAMES_TO_EXCLUDE = { NilClass => nil.methods } + NAMES_TO_EXCLUDE.default = [] + Ractor.make_shareable(NAMES_TO_EXCLUDE) if defined?(Ractor) + + # +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 + ) + + Ractor.make_shareable(RB_RESERVED_WORDS) if defined?(Ractor) + + def initialize(exception) + @method_name = exception.name + @receiver = exception.receiver + @private_call = exception.respond_to?(:private_call?) ? exception.private_call? : false + end + + def corrections + @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 + if Object === receiver + method_names = receiver.methods + receiver.singleton_methods + method_names += receiver.private_methods if @private_call + method_names.uniq! + # Assume that people trying to use a writer are not interested in a reader + # and vice versa + if method_name.match?(/=\Z/) + method_names.select! { |name| name.match?(/=\Z/) } + else + method_names.reject! { |name| name.match?(/=\Z/) } + end + method_names + else + [] + end + end + + def names_to_exclude + Object === receiver ? NAMES_TO_EXCLUDE[receiver.class] : [] + end + end +end diff --git a/lib/did_you_mean/spell_checkers/name_error_checkers.rb b/lib/did_you_mean/spell_checkers/name_error_checkers.rb new file mode 100644 index 0000000000..6e2aaa4cb1 --- /dev/null +++ b/lib/did_you_mean/spell_checkers/name_error_checkers.rb @@ -0,0 +1,20 @@ +require_relative 'name_error_checkers/class_name_checker' +require_relative 'name_error_checkers/variable_name_checker' + +module DidYouMean + class << (NameErrorCheckers = Object.new) + def new(exception) + case exception.original_message + when /uninitialized constant/ + ClassNameChecker + when /undefined local variable or method/, + /undefined method/, + /uninitialized class variable/, + /no member '.*' in struct/ + VariableNameChecker + else + NullChecker + end.new(exception) + end + end +end diff --git a/lib/did_you_mean/spell_checkers/name_error_checkers/class_name_checker.rb b/lib/did_you_mean/spell_checkers/name_error_checkers/class_name_checker.rb new file mode 100644 index 0000000000..924265b929 --- /dev/null +++ b/lib/did_you_mean/spell_checkers/name_error_checkers/class_name_checker.rb @@ -0,0 +1,49 @@ +# frozen-string-literal: true + +require_relative "../../spell_checker" + +module DidYouMean + class ClassNameChecker + attr_reader :class_name + + def initialize(exception) + @class_name, @receiver, @original_message = exception.name, exception.receiver, exception.original_message + end + + def corrections + @corrections ||= SpellChecker.new(dictionary: class_names) + .correct(class_name) + .map(&:full_name) + .reject {|qualified_name| @original_message.include?(qualified_name) } + end + + def class_names + scopes.flat_map do |scope| + scope.constants.map do |c| + ClassName.new(c, scope == Object ? "" : "#{scope}::") + end + end + end + + def scopes + @scopes ||= @receiver.to_s.split("::").inject([Object]) do |_scopes, scope| + _scopes << _scopes.last.const_get(scope) + end.uniq + end + + class ClassName < String + attr :namespace + + def initialize(name, namespace = '') + super(name.to_s) + @namespace = namespace + end + + def full_name + self.class.new("#{namespace}#{self}") + end + end + + private_constant :ClassName + end +end diff --git a/lib/did_you_mean/spell_checkers/name_error_checkers/variable_name_checker.rb b/lib/did_you_mean/spell_checkers/name_error_checkers/variable_name_checker.rb new file mode 100644 index 0000000000..9a6e04fe64 --- /dev/null +++ b/lib/did_you_mean/spell_checkers/name_error_checkers/variable_name_checker.rb @@ -0,0 +1,85 @@ +# frozen-string-literal: true + +require_relative "../../spell_checker" + +module DidYouMean + class VariableNameChecker + attr_reader :name, :method_names, :lvar_names, :ivar_names, :cvar_names + + NAMES_TO_EXCLUDE = { 'foo' => [:fork, :for] } + NAMES_TO_EXCLUDE.default = [] + Ractor.make_shareable(NAMES_TO_EXCLUDE) if defined?(Ractor) + + # +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__ + ) + + Ractor.make_shareable(RB_RESERVED_WORDS) if defined?(Ractor) + + def initialize(exception) + @name = exception.name.to_s.tr("@", "") + @lvar_names = exception.respond_to?(:local_variables) ? exception.local_variables : [] + receiver = exception.receiver + + @method_names = receiver.methods + receiver.private_methods + @ivar_names = receiver.instance_variables + @cvar_names = receiver.class.class_variables + @cvar_names += receiver.class_variables if receiver.kind_of?(Module) + end + + def corrections + @corrections ||= SpellChecker + .new(dictionary: (RB_RESERVED_WORDS + lvar_names + method_names + ivar_names + cvar_names)) + .correct(name).uniq - NAMES_TO_EXCLUDE[@name] + end + end +end diff --git a/lib/did_you_mean/spell_checkers/null_checker.rb b/lib/did_you_mean/spell_checkers/null_checker.rb new file mode 100644 index 0000000000..1306f69d4a --- /dev/null +++ b/lib/did_you_mean/spell_checkers/null_checker.rb @@ -0,0 +1,6 @@ +module DidYouMean + class NullChecker + def initialize(*); end + def corrections; [] end + end +end diff --git a/lib/did_you_mean/spell_checkers/pattern_key_name_checker.rb b/lib/did_you_mean/spell_checkers/pattern_key_name_checker.rb new file mode 100644 index 0000000000..622d4dee25 --- /dev/null +++ b/lib/did_you_mean/spell_checkers/pattern_key_name_checker.rb @@ -0,0 +1,28 @@ +require_relative "../spell_checker" + +module DidYouMean + class PatternKeyNameChecker + def initialize(no_matching_pattern_key_error) + @key = no_matching_pattern_key_error.key + @keys = no_matching_pattern_key_error.matchee.keys + end + + def corrections + @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 { |obj| format_object(obj) } + end + + def format_object(symbol_or_object) + if symbol_or_object.is_a?(Symbol) + ":#{symbol_or_object}" + else + symbol_or_object.to_s + end + end + end +end diff --git a/lib/did_you_mean/spell_checkers/require_path_checker.rb b/lib/did_you_mean/spell_checkers/require_path_checker.rb new file mode 100644 index 0000000000..586ced37de --- /dev/null +++ b/lib/did_you_mean/spell_checkers/require_path_checker.rb @@ -0,0 +1,39 @@ +# frozen-string-literal: true + +require_relative "../spell_checker" +require_relative "../tree_spell_checker" +require "rbconfig" + +module DidYouMean + class RequirePathChecker + attr_reader :path + + INITIAL_LOAD_PATH = $LOAD_PATH.dup.freeze + Ractor.make_shareable(INITIAL_LOAD_PATH) if defined?(Ractor) + + ENV_SPECIFIC_EXT = ".#{RbConfig::CONFIG["DLEXT"]}" + Ractor.make_shareable(ENV_SPECIFIC_EXT) if defined?(Ractor) + + 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 diff --git a/lib/did_you_mean/tree_spell_checker.rb b/lib/did_you_mean/tree_spell_checker.rb new file mode 100644 index 0000000000..799f07fcf0 --- /dev/null +++ b/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 diff --git a/lib/did_you_mean/verbose.rb b/lib/did_you_mean/verbose.rb new file mode 100644 index 0000000000..1ff19aef80 --- /dev/null +++ b/lib/did_you_mean/verbose.rb @@ -0,0 +1,2 @@ +warn "The verbose formatter has been removed and now `require 'did_you_mean/verbose'` has no effect. Please " \ + "remove this call." diff --git a/lib/did_you_mean/version.rb b/lib/did_you_mean/version.rb new file mode 100644 index 0000000000..85d80e4230 --- /dev/null +++ b/lib/did_you_mean/version.rb @@ -0,0 +1,3 @@ +module DidYouMean + VERSION = "2.0.0".freeze +end |