lunar 0.2.3 → 0.3.0

data/.gitignore

@@ -19,3 +19,4 @@ rdoc
 pkg
 
 ## PROJECT::SPECIFIC
+.rvmrc

data/README.md

@@ -40,6 +40,14 @@ Examples
           i.attr :name, name
           i.attr :description, description
         end
+
+        Lunar::Index.create Item do |i|
+          i.key id
+          i.fuzzy   :name, name # this has a 100 character limit on name
+                                # for performance reasons
+          i.integer :cost, cost
+          i.float   :voting_quotient, voting_quotient
+        end
       end
     end
 
@@ -49,6 +57,14 @@ Examples
 
     # Or opt to filter by field
     Lunar.search(Item, :name => "iphone", :description => "mobile")
+    
+    # For fuzzy declared fields you can currently only search 
+    # using a fuzzy strategy exclusively, e.g.
+    Lunar.search(Item, :fuzzy => { :name => "i" })
+    # i, ip, iph, ipho, iphone, 3, 3g, 3gs all would match 'iPhone 3Gs'
+    
+    # For integer / float types, you can do range searches on them e.g.
+    Lunar.search(Item, :cost => 300..500, :voting_quotient => 10..20)
 
     # Or using the pagination gem with this:
     @items = Lunar.search(Item, "iphone")

data/Rakefile

@@ -11,6 +11,7 @@ begin
     gem.homepage = "http://github.com/cyx/lunar"
     gem.authors = ["Cyril David"]
     gem.add_development_dependency "contest"
+    gem.add_development_dependency "mocha"
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
   Jeweler::GemcutterTasks.new

data/VERSION

@@ -1 +1 @@
-0.2.3
+0.3.0

data/lib/lunar.rb

@@ -2,12 +2,22 @@ require 'base64'
 require File.join(File.dirname(__FILE__), '..', 'vendor', 'nest', 'nest')
 
 module Lunar
-  autoload :Scoring,   'lunar/scoring'
-  autoload :Index,     'lunar/index'
-  autoload :Words,     'lunar/words'
-  autoload :Search,    'lunar/search'
-  autoload :Sets,      'lunar/sets'
-  autoload :ResultSet, 'lunar/result_set'
+  autoload :Scoring,           'lunar/scoring'
+  autoload :Index,             'lunar/index'
+  autoload :Words,             'lunar/words'
+  autoload :Search,            'lunar/search'
+  autoload :Sets,              'lunar/sets'
+  autoload :SortedResultSet,   'lunar/result_set'
+  autoload :UnsortedResultSet, 'lunar/result_set'
+  autoload :FuzzyWord,         'lunar/fuzzy_word'
+  
+  def self.ttl
+    @ttl ||= 30
+  end
+
+  def self.ttl=(ttl)
+    @ttl = ttl
+  end
 
   def self.redis(connection = defined?(Ohm) ? Ohm.redis : nil)
     @connection ||= connection 

data/lib/lunar/fuzzy_word.rb

@@ -0,0 +1,7 @@
+module Lunar
+  class FuzzyWord < String
+    def partials
+      (1..length).map { |i| self[0, i] }
+    end
+  end
+end

data/lib/lunar/index.rb

@@ -1,5 +1,9 @@
 module Lunar
   class Index
+    FUZZY_MAX_LENGTH = 100
+
+    FuzzyFieldTooLong = Class.new(StandardError)
+
     attr :ns
   
     def self.create(prefix)
@@ -15,6 +19,7 @@ module Lunar
       @attrs = {}
       @redis = (redis || Lunar.redis)
       @numeric_attrs = {}
+      @fuzzy_attrs = {}
     end
 
     def key(key = nil)
@@ -38,8 +43,14 @@ module Lunar
     alias :integer :numeric_attr
     alias :float   :numeric_attr
 
+    def fuzzy(field, value = nil)
+      @fuzzy_attrs[field.to_sym] = value if value
+      @fuzzy_attrs
+    end
+
     def index
       index_str_attrs
+      index_fuzzy_attrs
       index_numeric_attrs
 
       return self
@@ -53,7 +64,17 @@ module Lunar
         words.each do |w|
           @redis.zrem @ns[field][Lunar.encode(w)], key
         end
-        @redis.del k 
+        @redis.del k
+      end
+
+      fuzzy_keys = @redis.keys @ns[:Fuzzy][key]['*']
+      fuzzy_keys.each do |k|
+        field = k.gsub("#{ @ns[:Fuzzy][key] }:", '')
+        words = @redis.smembers(k)
+        words.each do |w|
+          remove_fuzzy_values field
+        end
+        @redis.del k
       end
     end
 
@@ -76,11 +97,40 @@ module Lunar
       end
     end
 
+    def index_fuzzy_attrs
+      @fuzzy_attrs.each do |field, value|
+        if value.to_s.length > FUZZY_MAX_LENGTH
+          raise FuzzyFieldTooLong, 
+            "#{field} has a value #{value} exceeding #{FUZZY_MAX_LENGTH} chars"
+        end
+
+        words = Words.new(value).uniq
+        words.each do |word|
+          FuzzyWord.new(word).partials.each do |partial|
+            @redis.sadd @ns[:Fuzzy][field][Lunar.encode(partial)], key
+          end
+          @redis.sadd @ns[:Fuzzy][key][field], word
+        end
+        
+        remove_fuzzy_values field, words
+      end
+    end
+    
+    def remove_fuzzy_values(field, words = [])
+      unused_words = @redis.smembers(@ns[:Fuzzy][key][field]) - words
+      unused_words.each do |word|
+        FuzzyWord.new(word).partials.each do |partial|
+          next if words.grep(/^#{partial}/u).any?
+          @redis.srem @ns[:Fuzzy][field][Lunar.encode(partial)], key
+        end
+        @redis.srem @ns[:Fuzzy][key][field], word
+      end
+    end
+
     def index_numeric_attrs
       @numeric_attrs.each do |field, value|
         @redis.zadd @ns[field], value, key
       end
     end
-
   end
 end

data/lib/lunar/result_set.rb

@@ -2,26 +2,43 @@ module Lunar
   class ResultSet
     include Enumerable
 
-    attr :sorted_set_key
+    attr :key
 
-    def initialize(sorted_set_key, &block)
-      @sorted_set_key = sorted_set_key
-      @block          = block
+    def initialize(key, &block)
+      @key   = key
+      @block = block
     end
 
     def each(&block)
       all.each(&block)
     end
+  end
 
+  class SortedResultSet < ResultSet
     def all(options = {})
       start  = Integer(options[:start] || 0)
-      finish = start + Integer(options[:limit] || 0) - 1
+      limit  = Integer(options[:limit] || 0)
+      finish = start + limit - 1
+      
+      puts "Getting: #{key}, #{Lunar.redis.zrange(key, start, finish)}" if $GAME
+      Lunar.redis.zrevrange(key, start, finish).map(&@block)
+    end
+
+    def size
+      Lunar.redis.zcard(key)
+    end
+  end
 
-      Lunar.redis.zrevrange(sorted_set_key, start, finish).map(&@block)
+  class UnsortedResultSet < ResultSet
+    def all(options = {})
+      start  = Integer(options[:start] || 0)
+      limit  = Integer(options[:limit] || 100)
+      
+      Lunar.redis.sort(key, :limit => [start, limit]).map(&@block)
     end
 
     def size
-      Lunar.redis.zcard(sorted_set_key)
+      Lunar.redis.scard(key)
     end
   end
 end

data/lib/lunar/search.rb

@@ -1,11 +1,20 @@
 module Lunar
   class Search
-    attr :sets, :prefix, :search_identifier
+    attr :sets, :prefix, :search_identifier, :fuzzy_sets
 
     def initialize(prefix, keywords)
       if keywords.is_a?(Hash)
-        @sets = keywords.inject([]) { |a, (field, query)| a | Sets.new(prefix, query, field) }
-        @search_identifier = keywords.hash
+        if fuzzy_hash = keywords.delete(:fuzzy)
+          @fuzzy_sets = fuzzy_hash.inject([]) { |a, (field, query)|
+            a | FuzzySets.new(prefix, query, field)
+          }
+          @search_identifier = fuzzy_hash.hash
+        else
+          @sets = keywords.inject([]) { |a, (field, query)| 
+            a | Sets.new(prefix, query, field) 
+          }
+          @search_identifier = keywords.hash
+        end
       else
         @sets = Sets.new(prefix, keywords)
         @search_identifier = keywords.hash
@@ -18,15 +27,28 @@ module Lunar
     end
 
     def results(&block)
-      return [] if sets.empty?
+      block ||= @finder
 
-      # TODO : cache this for X seconds, X seconds being customizable
-      Lunar.redis.zunion dist_key, sets.size, *sets
-      
-      if block_given?
-        ResultSet.new(dist_key, &block)
-      else
-        ResultSet.new(dist_key, &@finder)
+      if sets
+        if sets.empty?
+          return []
+        else
+          if not Lunar.redis.exists(dist_key)
+            Lunar.redis.zunion dist_key, sets.size, *sets
+            Lunar.redis.expire dist_key, Lunar.ttl
+          end
+          SortedResultSet.new(dist_key, &block)
+        end
+      elsif fuzzy_sets
+        if fuzzy_sets.empty?
+          return []
+        else
+          if not Lunar.redis.exists(dist_key)
+            Lunar.redis.sunionstore dist_key, *fuzzy_sets
+            Lunar.redis.expire dist_key, Lunar.ttl
+          end
+          UnsortedResultSet.new(dist_key, &block)
+        end
       end
     end
   

data/lib/lunar/sets.rb

@@ -14,6 +14,27 @@ module Lunar
     end
   end
   
+  class FuzzySets < Array
+    attr :prefix, :words, :field
+
+    def initialize(prefix, keywords, field)
+      @prefix = prefix
+      @field  = field
+      @words = Words.new(keywords)
+
+      super(redis_set_keys)
+    end
+  
+  protected
+    def redis_set_keys
+      words.map { |w| ns[Lunar.encode(w)] }
+    end
+
+    def ns
+      @ns ||= Lunar.nest[prefix][:Fuzzy][field]
+    end
+  end
+
   class RangeSets < Array
     attr :prefix, :field, :range
 
@@ -28,10 +49,8 @@ module Lunar
     def write_and_retrieve_key
       zrange = Lunar.redis.zrangebyscore(Lunar.nest[prefix][field], 
                                          @range.first, @range.last)
-      zrange.each do |id|
-        Lunar.redis.zadd key, 1, id 
-      end
-      # TODO :expire the key in X seconds where X is customizable
+
+      zrange.each { |id| Lunar.redis.zadd key, 1, id }
       key.to_s
     end
 

data/lunar.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{lunar}
-  s.version = "0.2.3"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Cyril David"]
-  s.date = %q{2010-05-03}
+  s.date = %q{2010-05-06}
   s.description = %q{uses sorted sets and sets, sorting by score}
   s.email = %q{cyx.ucron@gmail.com}
   s.extra_rdoc_files = [
@@ -25,6 +25,7 @@ Gem::Specification.new do |s|
      "VERSION",
      "examples/ohm.rb",
      "lib/lunar.rb",
+     "lib/lunar/fuzzy_word.rb",
      "lib/lunar/index.rb",
      "lib/lunar/result_set.rb",
      "lib/lunar/scoring.rb",
@@ -34,6 +35,8 @@ Gem::Specification.new do |s|
      "lunar.gemspec",
      "test/helper.rb",
      "test/test_lunar.rb",
+     "test/test_lunar_fuzzy.rb",
+     "test/test_lunar_fuzzy_word.rb",
      "test/test_lunar_index.rb",
      "test/test_lunar_scoring.rb",
      "test/test_lunar_search.rb",
@@ -80,6 +83,8 @@ Gem::Specification.new do |s|
   s.test_files = [
     "test/helper.rb",
      "test/test_lunar.rb",
+     "test/test_lunar_fuzzy.rb",
+     "test/test_lunar_fuzzy_word.rb",
      "test/test_lunar_index.rb",
      "test/test_lunar_scoring.rb",
      "test/test_lunar_search.rb",
@@ -93,11 +98,14 @@ Gem::Specification.new do |s|
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
       s.add_development_dependency(%q<contest>, [">= 0"])
+      s.add_development_dependency(%q<mocha>, [">= 0"])
     else
       s.add_dependency(%q<contest>, [">= 0"])
+      s.add_dependency(%q<mocha>, [">= 0"])
     end
   else
     s.add_dependency(%q<contest>, [">= 0"])
+    s.add_dependency(%q<mocha>, [">= 0"])
   end
 end
 

data/test/helper.rb

@@ -1,6 +1,7 @@
 require 'rubygems'
 require 'test/unit'
 require 'contest'
+require 'mocha'
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))

data/test/test_lunar_fuzzy.rb

@@ -0,0 +1,118 @@
+# 
+# module Lunar
+#   module Fuzzy
+# 
+#   end
+# end
+require "helper"
+
+class LunarFuzzyTest < Test::Unit::TestCase
+  setup do
+    Lunar.redis(Redis.new(:host => '127.0.0.1', :port => '6380'))
+    Lunar.redis.flushdb
+  end
+  
+  context "when setting fuzzy name, 'Yukihiro Matsumoto'" do
+    setup do
+      @index = Lunar::Index.create 'Item' do |i|
+        i.key  1001
+        i.fuzzy :name, 'Yukihiro Matsumoto'
+      end
+    end
+
+    should "store Lunar:Item:name:Y up to o and M up to o" do
+      fname, lname = 'yukihiro', 'matsumoto'
+    
+      (1..fname.length).each do |length|
+        key = "Lunar:Item:Fuzzy:name:#{ encode(fname[0, length]) }"
+        assert Lunar.redis.smembers(key).include?('1001')
+      end
+
+      (1..lname.length).each do |length|
+        key = "Lunar:Item:Fuzzy:name:#{ encode(lname[0, length]) }"
+        assert Lunar.redis.smembers(key).include?('1001')
+      end
+    end
+  end
+
+  context "when creating an index that already exists" do
+    setup do
+      @index = Lunar::Index.create 'Item' do |i|
+        i.key  1001
+        i.fuzzy :name, 'Yukihiro Matsumoto'
+      end
+
+      @index = Lunar::Index.create 'Item' do |i|
+        i.key  1001
+        i.fuzzy :name, 'Martin Fowler Yuki'
+      end
+    end
+    
+    should "remove all fuzzy entries for Yukihiro Matsumoto" do
+      fname, lname = 'yukihiro', 'matsumoto'
+
+      (5..fname.length).each do |length|
+        key = "Lunar:Item:Fuzzy:name:#{ encode(fname[0, length]) }"
+        assert ! Lunar.redis.smembers(key).include?('1001')
+      end
+
+      (3..lname.length).each do |length|
+        key = "Lunar:Item:Fuzzy:name:#{ encode(lname[0, length]) }"
+        assert ! Lunar.redis.smembers(key).include?('1001')
+      end
+    end
+
+    should "store Lunar:Item:name:M up to n and F up to r etc..." do
+      fname, lname, triple = 'martin', 'fowler', 'yuki'
+    
+      (1..fname.length).each do |length|
+        key = "Lunar:Item:Fuzzy:name:#{ encode(fname[0, length]) }"
+        assert Lunar.redis.smembers(key).include?('1001')
+      end
+
+      (1..lname.length).each do |length|
+        key = "Lunar:Item:Fuzzy:name:#{ encode(lname[0, length]) }"
+        assert Lunar.redis.smembers(key).include?('1001')
+      end
+
+      (1..triple.length).each do |length|
+        key = "Lunar:Item:Fuzzy:name:#{ encode(triple[0, length]) }"
+        assert Lunar.redis.smembers(key).include?('1001')
+      end
+    end
+  end
+  
+  context "on delete" do
+    setup do
+      @index = Lunar::Index.create 'Item' do |i|
+        i.key  1001
+        i.fuzzy :name, 'Yukihiro Matsumoto'
+      end
+
+      Lunar::Index.delete('Item', 1001)
+    end
+    
+    should "remove all fuzzy entries for Yukihiro Matsumoto" do
+      fname, lname = 'yukihiro', 'matsumoto'
+
+      (0..fname.length).each do |length|
+        key = "Lunar:Item:Fuzzy:name:#{ encode(fname[0, length]) }"
+        assert ! Lunar.redis.smembers(key).include?('1001')
+      end
+
+      (0..lname.length).each do |length|
+        key = "Lunar:Item:Fuzzy:name:#{ encode(lname[0, length]) }"
+        assert ! Lunar.redis.smembers(key).include?('1001')
+      end
+    end
+
+    should "also remove the key Lunar:Item:Fuzzy:1001:name" do
+      assert ! Lunar.redis.exists("Lunar:Item:Fuzzy:1001:name")
+    end
+  end
+
+protected
+  def encode(str)
+    Lunar.encode(str)
+  end
+end

data/test/test_lunar_fuzzy_word.rb

@@ -0,0 +1,14 @@
+require "helper"
+
+class LunarFuzzyWordTest < Test::Unit::TestCase
+  context "the word 'dictionary'" do
+    setup do
+      @w = Lunar::FuzzyWord.new('dictionary')
+    end
+    
+    should "have d, di, ... dictionary as it's partials" do
+      assert_equal ['d', 'di', 'dic', 'dict', 'dicti', 'dictio', 
+        'diction', 'dictiona', 'dictionar', 'dictionary'], @w.partials    
+    end
+  end
+end

data/test/test_lunar_index.rb

@@ -1,6 +1,11 @@
 require "helper"
 
 class LunarIndexTest < Test::Unit::TestCase
+  setup do
+    Lunar.redis(Redis.new(:host => '127.0.0.1', :port => '6380'))
+    Lunar.redis.flushdb
+  end
+
   context "given Item" do
     setup do
       @index = Lunar::Index.new('Item')
@@ -32,9 +37,6 @@ class LunarIndexTest < Test::Unit::TestCase
 
   context "on create" do
     setup do
-      Lunar.redis(Redis.new(:host => '127.0.0.1', :port => '6380'))
-      Lunar.redis.flushdb
-
       @index = Lunar::Index.create 'Item' do |i|
         i.key  1001
         i.attr :name, 'iphone 3G'
@@ -82,9 +84,6 @@ class LunarIndexTest < Test::Unit::TestCase
 
   context "when creating an index that already exists" do
     setup do
-      Lunar.redis(Redis.new(:host => '127.0.0.1', :port => '6380'))
-      Lunar.redis.flushdb
-
       @index = Lunar::Index.create 'Item' do |i|
         i.key  1001
         i.attr :name, 'iphone 3G'
@@ -135,9 +134,6 @@ class LunarIndexTest < Test::Unit::TestCase
   
   context "on delete" do
     setup do
-      Lunar.redis(Redis.new(:host => '127.0.0.1', :port => '6380'))
-      Lunar.redis.flushdb
-
       @index = Lunar::Index.create 'Item' do |i|
         i.key  1001
         i.attr :name, 'iphone 3G'
@@ -166,9 +162,6 @@ class LunarIndexTest < Test::Unit::TestCase
 
   context "on create of an index with numeric scores" do
     setup do
-      Lunar.redis(Redis.new(:host => '127.0.0.1', :port => '6380'))
-      Lunar.redis.flushdb
-
       @index = Lunar::Index.create 'Item' do |i|
         i.key  1001
         i.integer :cost, 2700

data/test/test_lunar_search.rb

@@ -6,7 +6,19 @@ class Item < Struct.new(:id)
   end
 end
 
+class Person < Struct.new(:id)
+  def self.[](id)
+    new(id)
+  end
+end
+
+
+
 class LunarSearchTest < Test::Unit::TestCase
+  setup do
+    Lunar.redis.flushdb
+  end
+
   context "searching when there exists no index yet" do
     should "return an empty set" do
       items = Lunar.search(Item, "foobar")
@@ -155,4 +167,89 @@ class LunarSearchTest < Test::Unit::TestCase
       assert items.map(&:id).include?('1003')
     end
   end
+
+  context "given Martin Fowler, Chad Fowler, and Frank Macallen" do
+    setup do
+      Lunar::Index.create "Person" do |i|
+        i.key 1001
+        i.fuzzy :name, 'Martin Fowler'
+      end
+
+      Lunar::Index.create "Person" do |i|
+        i.key 1002
+        i.fuzzy :name, 'Chad Fowler'
+      end
+
+      Lunar::Index.create "Person" do |i|
+        i.key 1003
+        i.fuzzy :name, 'Frank Macallen'
+      end
+    end
+
+    should "return Martin and Frank when searching M, and Ma" do
+      res1 = Lunar.search(Person, :fuzzy => { :name => 'M' })
+      res2 = Lunar.search(Person, :fuzzy => { :name => 'Ma' })
+
+      assert_equal %w{1001 1003}, res1.map(&:id)
+      assert_equal %w{1001 1003}, res2.map(&:id)
+    end
+
+    should "return only Martin when searching Mar up to Martin" do
+      res1 = Lunar.search(Person, :fuzzy => { :name => 'Mar' })
+      res2 = Lunar.search(Person, :fuzzy => { :name => 'Mart' })
+      res3 = Lunar.search(Person, :fuzzy => { :name => 'Marti' })
+      res4 = Lunar.search(Person, :fuzzy => { :name => 'Martin' })
+
+      assert_equal %w{1001}, res1.map(&:id)
+      assert_equal %w{1001}, res2.map(&:id)
+      assert_equal %w{1001}, res3.map(&:id)
+      assert_equal %w{1001}, res4.map(&:id)
+    end
+
+    should "return only Frank when searching Mac up to Macallen" do
+      res1 = Lunar.search(Person, :fuzzy => { :name => 'Mac' })
+      res2 = Lunar.search(Person, :fuzzy => { :name => 'Maca' })
+      res3 = Lunar.search(Person, :fuzzy => { :name => 'Macal' })
+      res4 = Lunar.search(Person, :fuzzy => { :name => 'Macall' })
+      res5 = Lunar.search(Person, :fuzzy => { :name => 'Macalle' })
+      res6 = Lunar.search(Person, :fuzzy => { :name => 'Macallen' })
+
+      assert_equal %w{1003}, res1.map(&:id)
+      assert_equal %w{1003}, res2.map(&:id)
+      assert_equal %w{1003}, res3.map(&:id)
+      assert_equal %w{1003}, res4.map(&:id)
+      assert_equal %w{1003}, res5.map(&:id)
+      assert_equal %w{1003}, res6.map(&:id)
+    end
+  
+    should "return the three of them when searching F" do
+      res1 = Lunar.search(Person, :fuzzy => { :name => 'F' })
+      
+      assert_equal %w{1001 1002 1003}, res1.map(&:id)
+    end
+
+    should "return the 2 fowlers when searching fo up to fowler" do
+      res1 = Lunar.search(Person, :fuzzy => { :name => 'Fo' })
+      res2 = Lunar.search(Person, :fuzzy => { :name => 'Fow' })
+      res3 = Lunar.search(Person, :fuzzy => { :name => 'Fowl' })
+      res4 = Lunar.search(Person, :fuzzy => { :name => 'Fowle' })
+      res5 = Lunar.search(Person, :fuzzy => { :name => 'Fowler' })
+      
+      assert_equal %w{1001 1002}, res1.map(&:id)
+      assert_equal %w{1001 1002}, res2.map(&:id)
+      assert_equal %w{1001 1002}, res3.map(&:id)
+      assert_equal %w{1001 1002}, res4.map(&:id)
+      assert_equal %w{1001 1002}, res5.map(&:id)
+    end
+
+    should "return be able to expire the stored union" do
+      Lunar.stubs(:ttl).returns(1)
+      search = Lunar::Search.new(Person, :fuzzy => { :name => 'Fo' })
+      search.results
+
+      assert Lunar.redis.exists search.send(:dist_key)
+      sleep 2
+      assert ! Lunar.redis.exists(search.send(:dist_key))
+    end
+  end
 end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 2
   - 3
-  version: 0.2.3
+  - 0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Cyril David
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-03 00:00:00 +08:00
+date: 2010-05-06 00:00:00 +08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -29,6 +29,18 @@ dependencies:
         version: "0"
   type: :development
   version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
 description: uses sorted sets and sets, sorting by score
 email: cyx.ucron@gmail.com
 executables: []
@@ -47,6 +59,7 @@ files:
 - VERSION
 - examples/ohm.rb
 - lib/lunar.rb
+- lib/lunar/fuzzy_word.rb
 - lib/lunar/index.rb
 - lib/lunar/result_set.rb
 - lib/lunar/scoring.rb
@@ -56,6 +69,8 @@ files:
 - lunar.gemspec
 - test/helper.rb
 - test/test_lunar.rb
+- test/test_lunar_fuzzy.rb
+- test/test_lunar_fuzzy_word.rb
 - test/test_lunar_index.rb
 - test/test_lunar_scoring.rb
 - test/test_lunar_search.rb
@@ -126,6 +141,8 @@ summary: a minimalistic full text search implementation in redis
 test_files: 
 - test/helper.rb
 - test/test_lunar.rb
+- test/test_lunar_fuzzy.rb
+- test/test_lunar_fuzzy_word.rb
 - test/test_lunar_index.rb
 - test/test_lunar_scoring.rb
 - test/test_lunar_search.rb