spellkit 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df48970adccf2bea2fae1a69f0e3704c0276bac9ab908a1bc5af6835edde0008
-  data.tar.gz: 28a8f37086361c742f902fa33bfd39003a1fff758b7ee306de1069344cf114d0
+  metadata.gz: 6e690fa50208d003679afff3117b6f00664e6938e7feb992eff6a6544fad279e
+  data.tar.gz: 17d41414cbd48e093913cfa8765aac063f1cb17283df13414ad801fdf0aa79ae
 SHA512:
-  metadata.gz: fcc1a0678ff2714a8844657f883354594d7bfb5be6e76a2708aa6134fa5ef9ef0a407a4be06a5f727e540ab99e6d21bc086a0bc740d3bd6cc2a5ed7c6d9458b0
-  data.tar.gz: 043b4f1aa59dd2ced9219f11736053d577d8afa7bdc83cb746ab91c4dc4bb1d5fd28c05aee79c09e739a3b1dd89c49ee088b2c189af81148db09ac40e0de1f06
+  metadata.gz: '0989bcacde87e9405c99f8674c681be65844a381cac11a00f8f05dd2f1a54312ce9d1799ca6317688255ee5fad454f4670845163b87e6a9541a981fff8685b35'
+  data.tar.gz: f12c69803c39ee74083a2090c85aac7bdfe7c39ac81995a95c09ad8c1e70df35cfb8d332de287413accf99aa4b6960e9e0c5f77ccd39b37d4ae092b06d8ea2d4

data/README.md

@@ -146,13 +146,13 @@ SpellKit.load!(
   protected_patterns: [/^[A-Z]{3,4}\d+$/]
 )
 
-# Use guard: :domain to enable protection
-SpellKit.correct("CDK10", guard: :domain)
+# Protected terms are automatically respected
+SpellKit.correct("CDK10")
 # => "CDK10"  # protected, never changed
 
-# Batch correction with guards
+# Batch correction with protection
 tokens = %w[helllo wrld ABC-123 for CDK10]
-SpellKit.correct_tokens(tokens, guard: :domain)
+SpellKit.correct_tokens(tokens)
 # => ["hello", "world", "ABC-123", "for", "CDK10"]
 ```
 
@@ -300,7 +300,7 @@ SpellKit.correct("rarword")   # => "rarword" (no correction if freq < 1000)
 
 ### Skip Patterns
 
-SpellKit can automatically skip certain patterns to avoid "correcting" technical terms, URLs, and other special content. Inspired by Aspell's filter modes, these patterns are applied when `guard: :domain` is enabled.
+SpellKit can automatically skip certain patterns to avoid "correcting" technical terms, URLs, and other special content. Inspired by Aspell's filter modes, these patterns are automatically applied when configured.
 
 **Available skip patterns:**
 
@@ -315,13 +315,13 @@ SpellKit.load!(
 )
 
 # With skip patterns enabled, technical content is preserved
-SpellKit.correct("https://example.com", guard: :domain)  # => "https://example.com"
-SpellKit.correct("user@test.com", guard: :domain)        # => "user@test.com"
-SpellKit.correct("getElementById", guard: :domain)       # => "getElementById"
-SpellKit.correct("version-1.2.3", guard: :domain)        # => "version-1.2.3"
+SpellKit.correct("https://example.com")  # => "https://example.com"
+SpellKit.correct("user@test.com")        # => "user@test.com"
+SpellKit.correct("getElementById")       # => "getElementById"
+SpellKit.correct("version-1.2.3")        # => "version-1.2.3"
 
 # Regular typos are still corrected
-SpellKit.correct("helllo", guard: :domain)               # => "hello"
+SpellKit.correct("helllo")               # => "hello"
 ```
 
 **What each skip pattern matches:**
@@ -351,9 +351,9 @@ SpellKit.load!(
   protected_patterns: [/^CUSTOM-\d+$/]  # Your custom patterns
 )
 
-# Both work together
-SpellKit.correct("https://example.com", guard: :domain)  # => "https://example.com" (skip_urls)
-SpellKit.correct("CUSTOM-123", guard: :domain)           # => "CUSTOM-123" (custom pattern)
+# Both work together automatically
+SpellKit.correct("https://example.com")  # => "https://example.com" (skip_urls)
+SpellKit.correct("CUSTOM-123")           # => "CUSTOM-123" (custom pattern)
 ```
 
 ## API Reference
@@ -426,33 +426,32 @@ SpellKit.suggestions("helllo", 5)
 # => [{"term"=>"hello", "distance"=>1, "freq"=>10000}, ...]
 ```
 
-### `SpellKit.correct(word, guard:)`
+### `SpellKit.correct(word)`
 
-Return corrected word or original if no better match found. Respects `frequency_threshold` configuration.
+Return corrected word or original if no better match found. Respects `frequency_threshold` configuration. Protected terms and skip patterns are automatically applied when configured.
 
 **Parameters:**
 - `word` (required) - The word to correct
-- `guard:` (optional) - Set to `:domain` to enable protection checks
 
 **Behavior:**
 - Returns original word if it exists in dictionary
 - For misspellings, only accepts corrections with frequency ≥ `frequency_threshold`
 - Returns original word if no corrections pass the threshold
-- When `guard: :domain` is set, protected terms and skip patterns are applied
+- Automatically respects protected terms and skip patterns configured in `load!`
 
 **Example:**
 ```ruby
-SpellKit.correct("helllo")                  # => "hello"
-SpellKit.correct("hello")                   # => "hello" (already correct)
-SpellKit.correct("CDK10", guard: :domain)   # => "CDK10" (protected)
+SpellKit.correct("helllo")  # => "hello"
+SpellKit.correct("hello")   # => "hello" (already correct)
+SpellKit.correct("CDK10")   # => "CDK10" (protected if configured)
 ```
 
-### `SpellKit.correct_tokens(tokens, guard:)`
+### `SpellKit.correct_tokens(tokens)`
 
-Batch correction of an array of tokens. Respects `frequency_threshold` configuration.
+Batch correction of an array of tokens. Respects `frequency_threshold` configuration. Protected terms and skip patterns are automatically applied when configured.
 
-**Options:**
-- `guard:` - Set to `:domain` to enable protection checks
+**Parameters:**
+- `tokens` (required) - Array of words to correct
 
 **Returns:** Array of corrected strings
 
@@ -472,7 +471,7 @@ Verify system is properly loaded. Raises error if not.
 
 ## Term Protection
 
-The `guard: :domain` option enables protection for specific terms:
+When configured, SpellKit automatically protects specific terms from correction:
 
 ### Exact Matches
 Terms in `protected_path` file are never corrected, even if similar dictionary words exist. Matching is case-insensitive, but original casing is preserved in output.
@@ -536,7 +535,7 @@ end
 class SearchPreprocessor
   def self.correct_query(text)
     tokens = text.downcase.split(/\s+/)
-    SpellKit.correct_tokens(tokens, guard: :domain).join(" ")
+    SpellKit.correct_tokens(tokens).join(" ")
   end
 end
 ```
@@ -554,10 +553,10 @@ end
 - `correct`: 1,858 i/s (538.17 μs/i)
 - `correct_tokens` (batch): 2,005 i/s (498.76 μs/i)
 
-**Guard Performance:**
-- Without guard: 2,926 i/s (341.79 μs/i)
-- With guard: 9,337 i/s (107.10 μs/i) - **3.19x faster!**
-  *(Guards short-circuit expensive lookups)*
+**Protection Performance:**
+- Without protection: 2,926 i/s (341.79 μs/i)
+- With protection: 9,337 i/s (107.10 μs/i) - **3.19x faster!**
+  *(Protection checks short-circuit expensive dictionary lookups)*
 
 **Latency Distribution (10,000 iterations):**
 - p50: 61μs

data/ext/spellkit/src/lib.rs

@@ -52,14 +52,11 @@ fn correct_word(
     state: &CheckerState,
     symspell: &SymSpell,
     word: &str,
-    use_guard: bool,
 ) -> String {
-    // Check if word is protected
-    if use_guard {
-        let normalized = SymSpell::normalize_word(word);
-        if state.guards.is_protected_normalized(word, &normalized) {
-            return word.to_string();
-        }
+    // Always check if word is protected
+    let normalized = SymSpell::normalize_word(word);
+    if state.guards.is_protected_normalized(word, &normalized) {
+        return word.to_string();
     }
 
     let suggestions = symspell.suggestions(word, 5);
@@ -298,7 +295,7 @@ impl Checker {
         }
     }
 
-    fn correct_if_unknown(&self, word: String, use_guard: Option<bool>) -> Result<String, Error> {
+    fn correct_if_unknown(&self, word: String) -> Result<String, Error> {
         let ruby = Ruby::get().unwrap();
         let state = self.state.read().unwrap();
 
@@ -307,18 +304,17 @@ impl Checker {
         }
 
         if let Some(ref symspell) = state.symspell {
-            Ok(correct_word(&state, symspell, &word, use_guard.unwrap_or(false)))
+            Ok(correct_word(&state, symspell, &word))
         } else {
             Err(Error::new(ruby.exception_runtime_error(), "SymSpell not initialized"))
         }
     }
 
-    fn correct_tokens(&self, tokens: RArray, use_guard: Option<bool>) -> Result<RArray, Error> {
+    fn correct_tokens(&self, tokens: RArray) -> Result<RArray, Error> {
         // Optimize batch correction by acquiring lock once for all tokens
         // instead of calling correct_if_unknown per token (which re-locks each time)
         let ruby = Ruby::get().unwrap();
         let state = self.state.read().unwrap();
-        let use_guard = use_guard.unwrap_or(false);
 
         if !state.loaded {
             return Err(Error::new(ruby.exception_runtime_error(), "Dictionary not loaded. Call load! first"));
@@ -329,7 +325,7 @@ impl Checker {
         if let Some(ref symspell) = state.symspell {
             for token in tokens.into_iter() {
                 let word: String = TryConvert::try_convert(token)?;
-                let corrected = correct_word(&state, symspell, &word, use_guard);
+                let corrected = correct_word(&state, symspell, &word);
                 result.push(corrected)?;
             }
 
@@ -388,8 +384,8 @@ fn init(_ruby: &Ruby) -> Result<(), Error> {
     checker_class.define_method("load!", method!(Checker::load_full, 1))?;
     checker_class.define_method("suggestions", method!(Checker::suggestions, 2))?;
     checker_class.define_method("correct?", method!(Checker::correct, 1))?;
-    checker_class.define_method("correct", method!(Checker::correct_if_unknown, 2))?;
-    checker_class.define_method("correct_tokens", method!(Checker::correct_tokens, 2))?;
+    checker_class.define_method("correct", method!(Checker::correct_if_unknown, 1))?;
+    checker_class.define_method("correct_tokens", method!(Checker::correct_tokens, 1))?;
     checker_class.define_method("stats", method!(Checker::stats, 0))?;
     checker_class.define_method("healthcheck", method!(Checker::healthcheck, 0))?;
 

data/lib/spellkit/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SpellKit
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/spellkit.rb

@@ -76,12 +76,12 @@ module SpellKit
       default.correct?(word)
     end
 
-    def correct(word, guard: nil)
-      default.correct(word, guard: guard)
+    def correct(word)
+      default.correct(word)
     end
 
-    def correct_tokens(tokens, guard: nil)
-      default.correct_tokens(tokens, guard: guard)
+    def correct_tokens(tokens)
+      default.correct_tokens(tokens)
     end
 
     def stats
@@ -211,19 +211,17 @@ class SpellKit::Checker
     _rust_correct?(word)
   end
 
-  def correct(word, guard: nil)
+  def correct(word)
     raise SpellKit::InvalidArgumentError, "word cannot be nil" if word.nil?
     raise SpellKit::InvalidArgumentError, "word cannot be empty" if word.to_s.empty?
 
-    use_guard = guard == :domain
-    _rust_correct(word, use_guard)
+    _rust_correct(word)
   end
 
-  def correct_tokens(tokens, guard: nil)
+  def correct_tokens(tokens)
     raise SpellKit::InvalidArgumentError, "tokens must be an Array" unless tokens.is_a?(Array)
 
-    use_guard = guard == :domain
-    _rust_correct_tokens(tokens, use_guard)
+    _rust_correct_tokens(tokens)
   end
 
   def stats

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spellkit
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Chris Petersen