kotoshu 0.3.0

data/examples/05_suggestion_algorithms.rb

@@ -0,0 +1,239 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Example 5: Suggestion Algorithms
+#
+# This example demonstrates how to use different suggestion algorithms
+# and build custom suggestion pipelines.
+
+require_relative "../lib/kotoshu"
+
+puts "=== Example 5: Suggestion Algorithms ==="
+puts
+
+# Create a test dictionary
+test_words = %w[
+  hello help held heap world
+  test text toast tost
+  run running runner
+  code coding coded
+  write writing writer
+  speak speaking speaker
+  read reading reader
+  walk walking walker
+  talk talking talker
+]
+
+test_dict = Kotoshu::Dictionary::Custom.new(
+  words: test_words,
+  language_code: "en"
+)
+
+puts "Test dictionary: #{test_dict.size} words"
+puts
+
+# Example 1: Edit Distance Strategy
+puts "1. Edit Distance Strategy"
+puts "-" * 40
+
+edit_strategy = Kotoshu::Suggestions::Strategies::EditDistanceStrategy.new
+context = Kotoshu::Suggestions::Context.new(
+  word: "helo",
+  dictionary: test_dict,
+  max_results: 5
+)
+
+result = edit_strategy.generate(context)
+puts "Suggestions for 'helo':"
+puts "  #{result.to_words.join(", ")}"
+puts "  Details:"
+result.each do |sugg|
+  puts "    • #{sugg.word} (distance: #{sugg.distance}, confidence: #{sugg.confidence.round(2)})"
+end
+
+puts
+puts "=" * 40
+puts
+
+# Example 2: Phonetic Strategy (Soundex)
+puts "2. Phonetic Strategy (Soundex)"
+puts "-" * 40
+
+phonetic_strategy = Kotoshu::Suggestions::Strategies::PhoneticStrategy.new(
+  algorithm: :soundex
+)
+
+context2 = Kotoshu::Suggestions::Context.new(
+  word: "hel",
+  dictionary: test_dict,
+  max_results: 5
+)
+
+result2 = phonetic_strategy.generate(context2)
+puts "Suggestions for 'hel' (Soundex):"
+puts "  #{result2.to_words.join(", ")}"
+
+# Show Soundex codes
+puts "\nSoundex codes:"
+puts "  'hel' -> #{phonetic_strategy.send(:soundex_code, "hel")}"
+test_words.each do |word|
+  code = phonetic_strategy.send(:soundex_code, word)
+  puts "  '#{word}' -> #{code}"
+end
+
+puts
+puts "=" * 40
+puts
+
+# Example 3: Phonetic Strategy (Metaphone)
+puts "3. Phonetic Strategy (Metaphone)"
+puts "-" * 40
+
+metaphone_strategy = Kotoshu::Suggestions::Strategies::PhoneticStrategy.new(
+  algorithm: :metaphone
+)
+
+context3 = Kotoshu::Suggestions::Context.new(
+  word: "fnix", # Should suggest "Phoenix"
+  dictionary: test_dict,
+  max_results: 5
+)
+
+# Add "phoenix" to dictionary for testing
+test_dict.add_word("phoenix")
+
+result3 = metaphone_strategy.generate(context3)
+puts "Suggestions for 'fnix' (Metaphone):"
+puts "  #{result3.to_words.join(", ")}"
+
+puts "\nMetaphone codes:"
+puts "  'fnix' -> #{metaphone_strategy.send(:metaphone_code, "fnix")}"
+puts "  'phoenix' -> #{metaphone_strategy.send(:metaphone_code, "phoenix")}"
+puts "  'finish' -> #{metaphone_strategy.send(:metaphone_code, "finish")}"
+
+puts
+puts "=" * 40
+puts
+
+# Example 4: N-Gram Strategy
+puts "4. N-Gram Strategy"
+puts "-" * 40
+
+ngram_strategy = Kotoshu::Suggestions::Strategies::NgramStrategy.new(
+  n: 2,
+  min_similarity: 0.2
+)
+
+context4 = Kotoshu::Suggestions::Context.new(
+  word: "tsting", # Should suggest "testing"
+  dictionary: test_dict,
+  max_results: 5
+)
+
+# Add "testing" to dictionary
+test_dict.add_word("testing")
+
+result4 = ngram_strategy.generate(context4)
+puts "Suggestions for 'tsting' (N-Gram, n=2):"
+puts "  #{result4.to_words.join(", ")}"
+
+puts
+puts "=" * 40
+puts
+
+# Example 5: Composite Strategy (Pipeline)
+puts "5. Composite Strategy (Pipeline)"
+puts "-" * 40
+
+# Build a pipeline with multiple strategies
+pipeline = Kotoshu.suggestion_pipeline(
+  Kotoshu::Suggestions::Strategies::EditDistanceStrategy.new,
+  Kotoshu::Suggestions::Strategies::PhoneticStrategy.new,
+  Kotoshu::Suggestions::Strategies::NgramStrategy.new(n: 2)
+)
+
+context5 = Kotoshu::Suggestions::Context.new(
+  word: "wrld",
+  dictionary: test_dict,
+  max_results: 10
+)
+
+result5 = pipeline.generate(context5)
+puts "Suggestions for 'wrld' (Composite Pipeline):"
+puts "  #{result5.to_words.join(", ")}"
+
+puts
+puts "Breakdown by source:"
+result5.from_source(:edit_distance).each do |sugg|
+  puts "  EditDistance: #{sugg.word} (distance: #{sugg.distance})"
+end
+result5.from_source(:phonetic).each do |sugg|
+  puts "  Phonetic: #{sugg.word}"
+end
+result5.from_source(:ngram).each do |sugg|
+  puts "  N-Gram: #{sugg.word}"
+end
+
+puts
+puts "=" * 40
+puts
+
+# Example 6: Custom Strategy
+puts "6. Custom Strategy"
+puts "-" * 40
+
+class PrefixStrategy < Kotoshu::Suggestions::Strategies::BaseStrategy
+  def generate(context)
+    word = context.word
+    dict_words = dictionary_words(context)
+
+    # Find words with same prefix
+    prefix_len = [word.length - 1, 3].max
+    prefix = word[0...prefix_len]
+
+    candidates = dict_words.select { |w| w.start_with?(prefix) && w != word }
+    create_suggestion_set(candidates)
+  end
+end
+
+prefix_strategy = PrefixStrategy.new(name: :prefix)
+
+context6 = Kotoshu::Suggestions::Context.new(
+  word: "hel", # Incomplete word
+  dictionary: test_dict,
+  max_results: 10
+)
+
+result6 = prefix_strategy.generate(context6)
+puts "Suggestions for 'hel' (Prefix-based):"
+puts "  #{result6.to_words.join(", ")}"
+
+puts
+puts "=" * 40
+puts
+
+# Example 7: Suggestion Generator
+puts "7. Suggestion Generator (High-level API)"
+puts "-" * 40
+
+generator = Kotoshu::Suggestions::Generator.new(
+  test_dict,
+  max_suggestions: 10,
+  algorithms: [
+    Kotoshu::Suggestions::Strategies::EditDistanceStrategy,
+    Kotoshu::Suggestions::Strategies::PhoneticStrategy
+  ]
+)
+
+puts "Generator configured with:"
+puts "  Dictionary: #{test_dict.size} words"
+puts "  Max suggestions: 10"
+puts "  Algorithms: EditDistanceStrategy, PhoneticStrategy"
+puts
+
+test_words = %w[helo wrld tsting fnix]
+test_words.each do |word|
+  suggestions = generator.suggest(word)
+  puts "Suggestions for '#{word}':"
+  puts "  #{suggestions.to_words.join(", ")}"
+end

data/examples/06_configuration_advanced.rb

@@ -0,0 +1,287 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Example 6: Configuration and Advanced Usage
+#
+# This example demonstrates how to configure Kotoshu and use
+# advanced features like custom words, multiple languages, etc.
+
+require_relative "../lib/kotoshu"
+
+puts "=== Example 6: Configuration and Advanced Usage ==="
+puts
+
+# Example 1: Global Configuration
+puts "1. Global Configuration"
+puts "-" * 40
+
+# Use system dictionary instead of non-existent path
+dict_path = if File.exist?("/usr/share/dict/words")
+              "/usr/share/dict/words"
+            elsif File.exist?("dictionaries/unix_words/words")
+              "dictionaries/unix_words/words"
+            else
+              # Will use auto-detected system dictionary
+              nil
+            end
+
+Kotoshu.configure do |config|
+  config.dictionary_type = :unix_words
+  config.dictionary_path = dict_path
+  config.language = "en-US"
+  config.max_suggestions = 15
+  config.case_sensitive = false
+  config.custom_words = %w[Kotoshu spellcheck]
+end
+
+puts "Configuration:"
+config = Kotoshu.configuration
+puts "  Dictionary type: #{config.dictionary_type}"
+puts "  Dictionary path: #{config.dictionary_path}"
+puts "  Language: #{config.language}"
+puts "  Max suggestions: #{config.max_suggestions}"
+puts "  Case sensitive: #{config.case_sensitive}"
+puts "  Custom words: #{config.custom_words.inspect}"
+puts
+
+# Use the configured spellchecker
+puts "Using configured spellchecker:"
+puts "  Has 'hello': #{Kotoshu.correct?("hello")}"
+puts "  Has 'Kotoshu': #{Kotoshu.correct?("Kotoshu")}"
+suggestions = Kotoshu.suggest("helo")
+puts "  Suggestions for 'helo': #{suggestions.to_words.first(10).join(", ")}..."
+
+puts
+puts "=" * 40
+puts
+
+# Example 2: Spellchecker Instance with Custom Configuration
+puts "2. Custom Spellchecker Instance"
+puts "-" * 40
+
+# Create a custom dictionary
+custom_dict = Kotoshu::Dictionary::Custom.new(
+  words: %w[ruby gem rspec rake bundler],
+  language_code: "en"
+)
+
+# Create a spellchecker with the custom dictionary
+custom_spellchecker = Kotoshu::Spellchecker.new(dictionary: custom_dict)
+
+puts "Custom spellchecker with Ruby-related words:"
+puts "  Has 'ruby': #{custom_spellchecker.correct?("ruby")}"
+puts "  Has 'gem': #{custom_spellchecker.correct?("gem")}"
+puts "  Has 'rake': #{custom_spellchecker.correct?("rake")}"
+puts "  Has 'python': #{custom_spellchecker.correct?("python")}"
+puts "  Suggestions for 'rke': #{custom_spellchecker.suggest("rke").to_words.join(", ")}"
+
+puts
+puts "=" * 40
+puts
+
+# Example 3: Dictionary Repository
+puts "3. Dictionary Repository"
+puts "-" * 40
+
+repo = Kotoshu::Dictionary::Repository.new
+
+# Register multiple dictionaries
+repo.register(:en_US, custom_dict)
+repo.register(:programming, Kotoshu::Dictionary::PlainText.from_words(
+                              %w[code function variable class module],
+                              language_code: "en"
+                            ))
+repo.register(:tech, Kotoshu::Dictionary::PlainText.from_words(
+                       %w[computer software hardware internet api],
+                       language_code: "en"
+                     ))
+
+puts "Registered dictionaries:"
+repo.each_key do |key|
+  dict = repo.get(key)
+  puts "  #{key}: #{dict.size} words (#{dict.type})"
+end
+
+puts "\nFind by language 'en':"
+found = repo.find_by_language("en")
+found.each do |dict|
+  puts "  #{dict.type}: #{dict.size} words"
+end
+
+puts
+puts "=" * 40
+puts
+
+# Example 4: IndexedDictionary
+puts "4. IndexedDictionary (Rich Query Interface)"
+puts "-" * 40
+
+index_dict = Kotoshu.dictionary(%w[
+                                  hello help held heap
+                                  world work word
+                                  test text toast
+                                  run running runner
+                                  code coding coded
+                                ])
+
+puts "IndexedDictionary: #{index_dict.size} words"
+puts
+
+puts "Query methods:"
+puts "  Words starting with 'he': #{index_dict.find_by_prefix("he").inspect}"
+puts "  Words ending with 'ld': #{index_dict.find_by_suffix("ld").inspect}"
+puts "  Words with length 3: #{index_dict.find_by_length(3).inspect}"
+puts "  Words matching pattern 't.*t': #{index_dict.find_by_pattern(/t.*t/).inspect}"
+puts
+
+puts "Statistics:"
+stats = index_dict.statistics
+stats.each do |key, value|
+  puts "  #{key}: #{value}"
+end
+
+puts
+puts "=" * 40
+puts
+
+# Example 5: WordResult and DocumentResult
+puts "5. Result Objects"
+puts "-" * 40
+
+# Check a word
+word_result = Kotoshu.spellchecker.check_word("hello")
+puts "WordResult for 'hello':"
+puts "  Word: #{word_result.word}"
+puts "  Correct: #{word_result.correct?}"
+puts "  Has suggestions: #{word_result.has_suggestions?}"
+puts
+
+word_result2 = Kotoshu.spellchecker.check_word("helo")
+puts "WordResult for 'helo':"
+puts "  Word: #{word_result2.word}"
+puts "  Correct: #{word_result2.correct?}"
+puts "  Suggestion count: #{word_result2.suggestion_count}"
+puts "  First suggestion: #{word_result2.first_suggestion}"
+puts "  Top 3: #{word_result2.top_suggestions(3).join(", ")}"
+puts
+
+# Check text
+text_result = Kotoshu.spellchecker.check("Hello wrold! This is a tst.")
+puts "DocumentResult:"
+puts "  Success: #{text_result.success?}"
+puts "  Word count: #{text_result.word_count}"
+puts "  Error count: #{text_result.error_count}"
+puts "  Unique errors: #{text_result.unique_error_count}"
+puts
+puts "  Errors:"
+text_result.errors.each do |error|
+  suggestions_str = if error.has_suggestions?
+                      " (suggestions: #{error.top_suggestions(2).join(", ")})"
+                    else
+                      ""
+                    end
+  puts "    • #{error.word} at position #{error.position}#{suggestions_str}"
+end
+
+puts
+puts "=" * 40
+puts
+
+# Example 6: Multiple File Checking
+puts "6. Batch File Checking"
+puts "-" * 40
+
+# Check multiple files
+fixtures_dir = "spec/fixtures/documents"
+if Dir.exist?(fixtures_dir)
+  files = Dir.glob(File.join(fixtures_dir, "*.txt"))
+  puts "Checking #{files.size} files..."
+  puts
+
+  files.each do |file|
+    result = Kotoshu.check_file(file)
+    status = result.success? ? "✓" : "✗"
+    filename = File.basename(file)
+    puts "#{status} #{filename}: #{result.error_count} error(s), #{result.word_count} words"
+  end
+
+  puts
+
+  # Get all results at once
+  results = Kotoshu.check_files(files)
+  total_errors = results.sum(&:error_count)
+  total_words = results.sum(&:word_count)
+  failed_count = results.count(&:failed?)
+
+  puts "Summary:"
+  puts "  Files checked: #{files.size}"
+  puts "  Files with errors: #{failed_count}"
+  puts "  Total errors: #{total_errors}"
+  puts "  Total words: #{total_words}"
+end
+
+puts
+puts "=" * 40
+puts
+
+# Example 7: Error Handling
+puts "7. Error Handling"
+puts "-" * 40
+
+begin
+  # Try to load a non-existent dictionary
+  bad_config = Kotoshu::Configuration.new(
+    dictionary_type: :plain_text,
+    dictionary_path: "/nonexistent/path.txt"
+  )
+  bad_config.load_dictionary
+rescue Kotoshu::DictionaryNotFoundError => e
+  puts "Caught DictionaryNotFoundError:"
+  puts "  Message: #{e.message}"
+  puts "  Path: #{e.path}"
+end
+
+puts
+
+begin
+  # Try to use an invalid dictionary type
+  bad_config2 = Kotoshu::Configuration.new(
+    dictionary_type: :invalid_type
+  )
+  bad_config2.load_dictionary
+rescue Kotoshu::ConfigurationError => e
+  puts "Caught ConfigurationError:"
+  puts "  Message: #{e.message}"
+  puts "  Key: #{e.key.inspect}"
+end
+
+puts
+puts "=" * 40
+puts
+
+# Example 8: Thread Safety (each instance is independent)
+puts "8. Thread Safety"
+puts "-" * 40
+
+# Create two independent spellcheckers
+spell1 = Kotoshu::Spellchecker.new(
+  dictionary: Kotoshu::Dictionary::Custom.new(
+    words: %w[hello world],
+    language_code: "en"
+  )
+)
+
+spell2 = Kotoshu::Spellchecker.new(
+  dictionary: Kotoshu::Dictionary::Custom.new(
+    words: %w[ruby python],
+    language_code: "en"
+  )
+)
+
+puts "Spellchecker 1 words: #{spell1.dictionary.words.inspect}"
+puts "Spellchecker 2 words: #{spell2.dictionary.words.inspect}"
+puts
+puts "Spellchecker 1 has 'hello': #{spell1.correct?("hello")}"
+puts "Spellchecker 1 has 'ruby': #{spell1.correct?("ruby")}"
+puts "Spellchecker 2 has 'hello': #{spell2.correct?("hello")}"
+puts "Spellchecker 2 has 'ruby': #{spell2.correct?("ruby")}"