redis-autosuggest 0.3.0 → 0.3.1

data/lib/redis/autosuggest/config.rb

@@ -55,12 +55,17 @@ class Redis
 
     # Maximum number of items to be indexed per n-gram (fuzzy matching)
     @ngram_item_limit = 200
+    
+    # If this is set to true, returned suggestions for fuzzy matching will only
+    # return suggestions that it has a very high confidence of in being correct.
+    @strict_fuzzy_matching = false
 
     class << self
       attr_reader :redis, :namespace
       attr_accessor :db, :items, :itemids, :substrings, :max_per_substring,
         :max_results, :max_str_size, :leaderboard, :use_leaderboard, :rails_sources,
-        :rails_source_sizes, :ngrams, :fuzzy_match, :ngram_size, :ngram_item_limit
+        :rails_source_sizes, :ngrams, :fuzzy_match, :ngram_size, :ngram_item_limit,
+        :strict_fuzzy_matching
 
       def redis=(redis)
         @redis = redis

data/lib/redis/autosuggest/fuzzy.rb

@@ -2,7 +2,7 @@ class Redis
   module Autosuggest
 
     class << self 
-      
+
       # Add an item's n-grams to the redis db. The n-grams will be used
       # as candidates for autocompletions when Redis::Autosuggest.fuzzy_match
       # is set to true.
@@ -13,26 +13,26 @@ class Redis
           end
         end
       end
-      
+
       # Remove an item's n-grams from the Redis db
       def remove_fuzzy(item)
         yield_ngrams(item) do |ngram| 
           @ngrams.srem(ngram, "#{item}:#{compute_soundex_code(item)}")
         end
       end
-      
+
       # Compute the soundex code of a string (only works for single words
       # so we have to merge multi-word strings)
       def compute_soundex_code(str)
         return Text::Soundex.soundex(alphabet_only(str))
       end
-      
+
       # Build a candidate pool for all suitable fuzzy matches for a string
       # by taking the union of all items in the Redis db that share an n-gram
       # with the string. Use levenshtein distance, soundex code similarity,
       # and the number of matching 2-grams to compute a score for each candidate.
       # Then return the highest-scoring candidates.
-      def suggest_fuzzy(str, results=@max_results)
+      def suggest_fuzzy(str, results=@max_results, strict=@strict_fuzzy_matching)
         str_mul = alphabet_only(str).size
         str_soundex_code = compute_soundex_code(str)
         str_2grams = ngram_list(str, 2)
@@ -59,20 +59,38 @@ class Redis
           same_2grams = str_2grams & ngram_list(candidate_str, 2)
           candidate_score *= Math.exp(same_2grams.size)
 
-          candidates << [candidate_str, candidate_score] if candidate_score > 1
+          if candidate_score > 1
+            candidates << {
+              str: candidate_str,
+              score: candidate_score
+            }
+          end
         end
         # Sort results by score and return the highest scoring candidates
-        candidates = candidates.sort { |a, b| b[1] <=> a[1] }
-        # puts candidates.take(10).map { |tuple| "#{tuple[0]} => #{tuple[1]}" }
-        return candidates.take(results).map { |a| a[0] }
+        candidates = candidates.sort { |a, b| b[:score] <=> a[:score] }
+        # puts candidates.take(10).map { |cand| "#{cand[:str]} => #{cand[:score]}" }
+        # If strict fuzzy matching is used, only suggestion items with scores
+        # above a certain threshold will be returned.
+        if strict
+          suggestions = []
+          candidates.each do |cand|
+            # threshold ||= candidates[0][:score] / 10
+            threshold = Math.exp(str.size)
+            break if suggestions.size > results || cand[:score] < threshold
+            suggestions << cand
+          end
+        else
+          suggestions = candidates.take(results)
+        end
+        return suggestions.map { |cand| cand[:str] }
       end
-      
+
       # Yield the n-grams of a specified size for a string one at a time
       def yield_ngrams(str, ngram_size=@ngram_size)
         ngram_list = ngram_list(str, ngram_size)
         ngram_list.each { |ngram| yield ngram }
       end
-      
+
       # Returns a list containing all of the n-grams of a specified size
       # of a string.  The list is ordered by the position of the n-gram
       # in the string (duplicates included).
@@ -86,7 +104,7 @@ class Redis
         end
         ngram_list
       end
-      
+
       # Remove all characters not in the range 'a-z' from a string
       def alphabet_only(str)
         return str.gsub(/[^abcdefghijklmnopqrstuvwxyz]/, '')

data/lib/redis/autosuggest/version.rb

@@ -1,5 +1,5 @@
 class Redis
   module Autosuggest
-    VERSION = "0.3.0"
+    VERSION = "0.3.1"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis-autosuggest
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-08 00:00:00.000000000 Z
+date: 2013-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis