LittleWeasel 3.0.0 → 4.0.0

data/Rakefile

@@ -1,13 +1,306 @@
-require "bundler/gem_tasks"
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/try.rb'
+require 'active_support/inflector'
+require 'benchmark/ips'
+require 'bundler/gem_tasks'
+require 'pry'
+
+require_relative 'lib/LittleWeasel'
+require_relative 'spec/support/file_helpers'
+require_relative 'spec/support/general_helpers'
+
+DictionaryResultsHelpers = Support::GeneralHelpers::DictionaryResultsHelpers
+
+def file_from(dictionary_key)
+  Support::FileHelpers.dictionary_path_for(file_name: dictionary_key.key)
+end
 
 begin
   require 'rspec/core/rake_task'
   RSpec::Core::RakeTask.new(:spec)
 rescue LoadError => e
-  task "spec" do
+  task 'spec' do
     puts "RSpec not loaded - make sure it's installed and you're using bundle exec"
     exit 1
   end
 end
 
-task :default => :spec
+#
+# Tasks related to the #word_results API
+
+namespace 'word_results' do
+  # Creates a dictionary from a file on disk
+  task :basic do
+    LittleWeasel.configure do |config|
+      # TODO: Configure as needed here.
+    end
+
+    # Create a Dictionary Manager.
+    dictionary_manager = LittleWeasel::DictionaryManager.new
+
+    # Create our unique key for the dictionary.
+    en_us_key = LittleWeasel::DictionaryKey.new(language: :en, region: :us)
+
+    file = Support::FileHelpers.dictionary_path_for file_name: en_us_key.key
+
+    # Create a dictionary of names from memory.
+    en_us_names_dictionary = dictionary_manager.create_dictionary_from_file(
+      dictionary_key: en_us_key,
+      file: file)
+
+    # Get some word results...
+
+    # Get results for a word we know exists.
+    word = 'apple'
+    word_results = en_us_names_dictionary.word_results word
+    DictionaryResultsHelpers.print_word_results word, word_results, "found (#{word} is in the dictionary)"
+
+    # Get results for a word we know DOES NOT exist.
+    word = 'dapple'
+    word_results = en_us_names_dictionary.word_results word
+    DictionaryResultsHelpers.print_word_results word, word_results, "not found (#{word} is not in the dictionary)"
+  rescue StandardError => e
+    task 'word_results:basic' do
+      puts "LittleWeasel task word_results:basic not loaded: #{e.message}"
+      exit 1
+    end
+  end
+
+  # Creates a dictionary of names from memory
+  task :from_memory do
+    LittleWeasel.configure do |config|
+      # TODO: Configure as needed here.
+    end
+
+    # Create a Dictionary Manager.
+    dictionary_manager = LittleWeasel::DictionaryManager.new
+
+    # Create our unique key for the dictionary.
+    en_us_names_key = LittleWeasel::DictionaryKey.new(language: :en, region: :us, tag: :names)
+
+    # Create a dictionary of names from memory.
+    en_us_names_dictionary = dictionary_manager.create_dictionary_from_memory(
+      dictionary_key: en_us_names_key, dictionary_words: %w(Abel Bartholomew Cain Deborah Elijah))
+
+    # Get some word results...
+
+    # Get results for a name we know exists.
+    word = 'Abel'
+    word_results = en_us_names_dictionary.word_results word
+    DictionaryResultsHelpers.print_word_results word, word_results, "found (#{word} is in the dictionary)"
+
+    # Get results for a name we know DOES NOT exist.
+    word = 'Henry'
+    word_results = en_us_names_dictionary.word_results word
+    DictionaryResultsHelpers.print_word_results word, word_results, "not found (#{word} is not in the dictionary)"
+  rescue StandardError => e
+    task 'word_results:from_memory' do
+      puts "LittleWeasel task word_results:from_memory not loaded: #{e.message}"
+      exit 1
+    end
+  end
+
+  # Shows application of word filters and word preprocessors.
+  task :advanced do
+    LittleWeasel.configure do |config|
+      # TODO: Configure as needed here.
+    end
+
+    # Create a Dictionary Manager.
+    dictionary_manager = LittleWeasel::DictionaryManager.new
+
+    # Create our unique key for the dictionary.
+    en_us_names_key = LittleWeasel::DictionaryKey.new(language: :en, region: :us, tag: :names)
+
+    # Create a Henry word filter.
+    class HenryFilter < LittleWeasel::Filters::WordFilter
+      class << self
+        def filter_match?(word)
+          word== 'Henry'
+        end
+      end
+    end
+    word_filters = [HenryFilter.new]
+
+    # Add a word preprocessor.
+    word_preprocessors = [LittleWeasel::Preprocessors::EnUs::CapitalizePreprocessor.new]
+
+    # Create a dictionary of names from memory.
+    en_us_names_dictionary = dictionary_manager.create_dictionary_from_memory(
+      dictionary_key: en_us_names_key,
+      dictionary_words: %w(Abel Bartholomew Cain Deborah Elijah),
+      word_filters: word_filters,
+      word_preprocessors: word_preprocessors)
+
+    puts '# Turning off our word filters and word preprocessors to start...'
+    puts
+
+    en_us_names_dictionary.filters_on = false
+    en_us_names_dictionary.preprocessors_on = false
+
+    # Get results for a name we know DOES NOT exist.
+    word = 'Henry'
+    word_results = en_us_names_dictionary.word_results word
+    DictionaryResultsHelpers.print_word_results word, word_results, "not found, #success? == false, word_valid? == false (#{word} is not in the dictionary)"
+
+    puts '# Turning word filters on...'
+    puts
+
+    en_us_names_dictionary.filters_on = true
+
+    # Get results for Henry again - it should be found due to the filter.
+    word = 'Henry'
+    word_results = en_us_names_dictionary.word_results word
+    DictionaryResultsHelpers.print_word_results word, word_results, '#success? == true due to the HenryFilter'
+
+    # Get results for a name we know DOES NOT exist.
+    word = 'henry'
+    word_results = en_us_names_dictionary.word_results word
+    DictionaryResultsHelpers.print_word_results word, word_results, "not found, #success? == false (#{word} is not in the dictionary and henry is lower case, no filter match)"
+
+    puts '# Turning preprocessors on so that henry is converted to Henry '
+    puts "# and consequently, the filter will match..."
+    puts
+
+    en_us_names_dictionary.preprocessors_on = true
+
+    word = 'henry'
+    word_results = en_us_names_dictionary.word_results word
+    DictionaryResultsHelpers.print_word_results word, word_results, "#success? == true, #filter_match? == true (#{word} is not in the dictionary but the word preprocessor and word filter work together to get a filter match and consider the name valid)"
+  rescue StandardError => e
+    task 'word_results:advanced' do
+      puts "LittleWeasel task word_results:advanced not loaded: #{e.message}"
+      exit 1
+    end
+  end
+
+  task :word_filters do
+    LittleWeasel.configure do |config|
+      # TODO: Configure as needed here.
+    end
+    dictionary_manager = LittleWeasel::DictionaryManager.new
+    dictionary_key = LittleWeasel::DictionaryKey.new(language: :en, region: :us)
+    file = Support::FileHelpers.dictionary_path_for file_name: dictionary_key.key
+    word_filters = [
+      LittleWeasel::Filters::EnUs::NumericFilter.new,
+      LittleWeasel::Filters::EnUs::CurrencyFilter.new,
+      LittleWeasel::Filters::EnUs::SingleCharacterWordFilter.new
+    ]
+    word_preprocessors = nil
+    dictionary_words = Support::FileHelpers.dictionary_words_for dictionary_file_path: file
+    dictionary = dictionary_manager.create_dictionary_from_memory(dictionary_key: dictionary_key, dictionary_words: dictionary_words, word_filters: word_filters, word_preprocessors: word_preprocessors)
+    dictionary_words << 'A'.dup
+    dictionary_words << 'I'.dup
+    dictionary_words << '1000'.dup
+    dictionary_words << '1,000'.dup
+    dictionary_words << '10,000.00'.dup
+    dictionary_words << '+100.00'.dup
+    dictionary_words << '-200,000.00'.dup
+    dictionary_words << '$100,000'.dup
+    dictionary_words << '+$100,000,000.10'.dup
+    dictionary_words << '-$999,000,000.10'.dup
+    dictionary_words.each do |word|
+      word.strip!
+      word_results = dictionary.word_results word
+      DictionaryResultsHelpers.print_word_results word, word_results
+    end
+  rescue StandardError => e
+    task 'word_results:word_filters' do
+      puts "LittleWeasel task word_results:word_filters not loaded: #{e.message}"
+      exit 1
+    end
+  end
+end
+
+#
+# Tasks related to the #block_results API
+
+namespace 'block_results' do
+  task :basic do
+    LittleWeasel.configure do |config|
+      # TODO: Configure as needed here.
+    end
+
+    # Create a Dictionary Manager.
+    dictionary_manager = LittleWeasel::DictionaryManager.new
+
+    # Create our unique key for the dictionary.
+    en_us_key = LittleWeasel::DictionaryKey.new(language: :en, region: :us, tag: :big)
+
+    # Create a dictionary from a file on disk. The below assumes the
+    # dictionary file name matches the dictionary key (e.g. en-US-big).
+    en_us_dictionary = dictionary_manager.create_dictionary_from_file(
+      dictionary_key: en_us_key, file: file_from(en_us_key))
+
+    word_block = "This is a word-block of 8 words and 2 numbers."
+
+    # Add a word filter so that numbers are considered valid.
+    en_us_dictionary.add_filters word_filters: [
+      LittleWeasel::Filters::EnUs::NumericFilter.new
+    ]
+
+    block_results = en_us_dictionary.block_results word_block
+
+    # Returns a LittleWeasel::BlockResults object.
+    DictionaryResultsHelpers.print_block_results word_block, block_results
+  rescue StandardError => e
+    task 'block_results:basic' do
+      puts "LittleWeasel task block_results:basic not loaded: #{e.message}"
+      exit 1
+    end
+  end
+end
+
+namespace :bm do
+  task :hash do
+    STRING_LOCALE = { 'en-US' => 'en-us' }
+    SYMBOL_LOCALE = { 'en-US' => :enUS }
+
+    puts 'String variable vs. normal String.'
+    Benchmark.ips do |x|
+      string_variable = 'string_variable'
+      x.report('string variable') { STRING_LOCALE[string_variable] }
+      x.report('normal') { STRING_LOCALE['en-US'] }
+    end
+
+    puts 'String#freeze vs. normal String.'
+    Benchmark.ips do |x|
+      x.report('freeze') { STRING_LOCALE['en-US'.freeze] }
+      x.report('normal') { STRING_LOCALE['en-US'] }
+    end
+
+    puts 'String vs Symbol'
+    Benchmark.ips do |x|
+      x.report('string') { STRING_LOCALE['en-US'] }
+      x.report('symbol') { SYMBOL_LOCALE[:enUS] }
+    end
+
+    puts 'String#freeze vs. Symbol'
+    Benchmark.ips do |x|
+      x.report('string') { STRING_LOCALE['en-US'.freeze] }
+      x.report('symbol') { SYMBOL_LOCALE[:enUS] }
+    end
+  rescue StandardError => e
+    task 'hash' do
+      puts "LittleWeasel task bm:hash not loaded: #{e.message}"
+      exit 1
+    end
+  end
+
+  task :dictionary_key do
+    puts 'DictionaryKey test'
+    Benchmark.ips do |x|
+      x.report('DictionaryKey') do
+        DictionaryKey.key(language: :en, region: :us, tag: :tag)
+      end
+    end
+  rescue StandardError => e
+    task 'locale' do
+      puts "LittleWeasel task bm:dictionary_key not loaded: #{e.message}"
+      exit 1
+    end
+  end
+end
+
+task default: :spec

data/lib/LittleWeasel.rb

@@ -1,173 +1,7 @@
-require 'singleton'
-require "LittleWeasel/version"
-require 'active_support/inflector'
+# frozen_string_literal: true
 
-module LittleWeasel
+require 'active_support/core_ext/object/blank'
 
-  # Provides methods to interrogate the dictionary.
-  class Checker
-    include Singleton
-
-    # Returns the dictionary.
-    #
-    # @return [Hash] the dictionary.
-    attr_reader :dictionary
-
-    private
-
-    attr_reader :alphabet_exclusion_list
-
-    # Keep these private...will expose as options later.
-    attr_accessor :word_regex, :numeric_regex, :non_wordchar_regex
-
-    public
-
-    # The constructor
-    def initialize
-      @options = {exclude_alphabet: false, strip_whitespace: false, ignore_numeric: true}
-      @alphabet_exclusion_list = %w{ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z }
-      @numeric_regex = /^[-+]?[0-9]?(\.[0-9]+)?$+/
-      @word_regex = /\s+(?=(?:[^"]*"[^"]*")*[^"]*$)/
-      @non_wordchar_regex = /\W+/
-      @dictionary = Hash.new(1)
-      load
-    end
-
-    # Interrogates the dictionary to determine whether or not [word] exists.
-    #
-    # @param [String] word the word or words to interrogate
-    # @param [Hash] options options to apply to this query (see #options=).  Options passed to this
-    #   method are applied for this query only.
-    #
-    # @return [Boolean] true if the word/words in *word* exists, false otherwise.
-    #
-    # @example
-    #
-    #  LittleWeasel::Checker.instance.exists?('C') # true (default options, :exclude_alphabet => false)
-    #  LittleWeasel::Checker.instance.exists?('A', {exclude_alphabet:true}) # false
-    #  LittleWeasel::Checker.instance.exists?('X', {exclude_alphabet:false}) # true
-    #  LittleWeasel::Checker.instance.exists?('Hello') # true
-    #
-    #  LittleWeasel::Checker.instance.exists?(' Hello ') # false (default options, :strip_whitespace => false)
-    #  LittleWeasel::Checker.instance.exists?(' Yes ', {strip_whitespace:true}) # true
-    #  LittleWeasel::Checker.instance.exists?('No ', {strip_whitespace:false}) # false
-    #  LittleWeasel::Checker.instance.exists?('How dy', {strip_whitespace:true}) # false, strip_whitespace only removes leading and trailing spaces
-    #
-    #  LittleWeasel::Checker.instance.exists?('90210') # true (default options, ignore_numeric => true)
-    #  LittleWeasel::Checker.instance.exists?('90210', {ignore_numeric:false}) # false
-    #
-    #  LittleWeasel::Checker.instance.exists?('Hello World') # true, we're accepting multiple words now :)}
-    #  LittleWeasel::Checker.instance.exists?("hello, mister; did I \'mention\'' that lemon cake is \"great?\" It's just wonderful!") # true
-    #
-    def exists?(word, options=nil)
-      options = options || @options
-
-      return false unless word.is_a?(String)
-
-      word.strip! if options[:strip_whitespace]
-
-      return false if word.empty?
-      return block_exists? word if block?(word)
-      return true if options[:ignore_numeric] && number?(word)
-      return false if options[:exclude_alphabet] && word.length == 1 && @alphabet_exclusion_list.include?(word.upcase)
-
-      valid_word? word
-    end
-
-    # Sets the global options for this gem.
-    #
-    # @param [Hash] options options that should apply to all subsequent calls to method *exists?* (see #exists?).
-    #  Options set via this property apply to all subsequent queries.
-    # @option options [Boolean] :exclude_alphabet (false) If false, letters of the alphabet are considered words.
-    #  For example, LittleWeasel::Checker.instance.exists?('A'), will return true.
-    # @option options [Boolean] :strip_whitespace (false) If true, leading and trailing spaces are removed before checking to see if the word exists.
-    #  For example, LittleWeasel::Checker.instance.exists?(' Hello ', {strip_whitespace:true}), will return true.
-    # @option options [Boolean] :ignore_numeric (true) If true, numeric values are considered valid words.
-    #  For example, LittleWeasel::Checker.instance.exists?('1999', {ignore_numeric:true}), will return true.                                                                                                                                         #  For example, LittleWeasel::Checker.instance.exists?(' Hello ', {strip_whitespace:true}), will return true.
-    #
-    # @return [Hash] The options
-    #
-    # @example
-    #  LittleWeasel::Checker.instance.options({exclude_alphabet:true})
-    #  LittleWeasel::Checker.instance.exists?('A') # false
-    #
-    #  LittleWeasel::Checker.instance.options({exclude_alphabet:false})
-    #  LittleWeasel::Checker.instance.exists?('A') # true
-    #
-    #  LittleWeasel::Checker.instance.options({strip_whitespace:false})
-    #  LittleWeasel::Checker.instance.exists?(' Hello ') # false
-    #  LittleWeasel::Checker.instance.exists?('No ') # false
-    #  LittleWeasel::Checker.instance.exists?(' No') # false
-    #
-    #  LittleWeasel::Checker.instance.options({strip_whitespace:true})
-    #  LittleWeasel::Checker.instance.exists?(' Yes ') # true
-    #  LittleWeasel::Checker.instance.exists?('How dy') # false, strip_whitespace only removes leading and trailing spaces
-    #
-    #  LittleWeasel::Checker.instance.exists?('90210') # true (default options, ignore_numeric => true)
-    #  LittleWeasel::Checker.instance.exists?('90210', {ignore_numeric:false}) # false
-    #  LittleWeasel::Checker.instance.exists?('I watch Beverly Hills 90210') # true (default options, ignore_numeric => true)
-    #  LittleWeasel::Checker.instance.exists?('I watch Beverly Hills 90210', {ignore_numeric:false}) # false
-    #
-    def options=(options)
-      @options = options
-    end
-
-    # Gets the global options currently set for this gem.
-    #
-    # @return [Hash] The options
-    def options
-      @options
-    end
-
-    protected
-
-    def number?(word)
-      word.strip.gsub(@numeric_regex).count > 0
-    end
-
-    def block?(string)
-      tmp = string
-      return false unless tmp.is_a?(String)
-      tmp.gsub!(@numeric_regex, "")
-      return false unless tmp.length > 1
-      tmp.strip.scan(/[\w'-]+/).length > 1
-    end
-
-    def block_exists?(block)
-      tmp = block
-      tmp.gsub!(@numeric_regex, "").squeeze(" ").strip if options[:ignore_numeric]
-      tmp.gsub!(@non_wordchar_regex, " ")
-      tmp.split(@word_regex).uniq.each { |word|
-        return false unless valid_block_word?(word)
-      }
-      return true
-    end
-
-    def valid_word?(word)
-      tmp = word.downcase
-      exists = dictionary.has_key?(tmp)
-      exists = dictionary.has_key?(tmp.singularize) unless exists
-      #puts "=> exists?(#{word}=>#{tmp}) # => #{exists}"
-      exists
-    end
-
-    def valid_block_word?(word)
-      return true if word.length == 1
-      valid_word? word.strip
-    end
-
-    private
-
-    def dictionary_path
-      File.expand_path(File.dirname(__FILE__) + '/dictionary')
-    end
-
-    def load
-      File.open(dictionary_path) do |io|
-        io.each { |line| line.chomp!; @dictionary[line] = line }
-      end
-    end
-
-  end
-
-end
+Dir[File.join('.', 'lib/LittleWeasel/**/*.rb')].each do |f|
+  require f
+end