lunar 0.4.1 → 0.5.0

data/.document

@@ -1,5 +0,0 @@
-README.rdoc
-lib/**/*.rb
-bin/*
-features/**/*.feature
-LICENSE

data/DATA

@@ -1,41 +0,0 @@
-
-Item
-- id: 1
-- name: 'iphone 3g'
-- tags: 'apple mobile'
-
-Item
-- id: 2
-- name: 'nokia n95'
-- tags: 'symbian mobile'
-
-q: mobile
-
-
-Item:name:iphone => 1004 1001
-Item:name:3gs => 1001
-Item:name:apple => 1004 1003 1002
-Item:name:macbook => 1003 1002
-Item:name:pro => 1003 1002
-Item:name:17 => 1003 1002
-Item:desc:iphone => 1004 1003 1002
-Item:desc:4g => 1004 1003
-
-Keywords Only
--------------
-iphone => 1004 1001 1003 1002
-3gs    => 1001
-apple  => 1004 1003 1002
-macbook => 1002 1003
-pro     => 1002 1003
-17      => 17
-4g      => 1003 1004
-
-Key value pairs
----------------
-name: iphone => 1001 1004
-name: iphone, desc: iphone => 1004
-name: iphone, desc: 4g => 1004
-name: apple, desc: iphone => 1002, 1003, 1004
-name: apple macbook pro, desc: iphone => 1002 1003
-name: apple macbook pro 17, desc: 4g => 1003

data/README.md

@@ -1,80 +0,0 @@
-Lunar
-=====
-
-A minimalistic search index implemented using Redis, taking advantage of its 
-powerful `sorted sets` and the ability to do set intersection and union.
-
-Results are sorted by their word score, which is stored as the score in the
-Redis sorted set.
-
-Examples
---------
-
-    class Item < Ohm::Model
-      attribute :name
-      attribute :description
-      
-    protected
-      def write
-        super
-        index
-      end
-
-      def index
-        Lunar::Index.create 'Item' do |i|
-          i.key  id
-          i.attr :name, name
-          i.attr :description, description
-        end
-        
-        # You can also do this, no problem
-        Lunar::Index.create Item do |i|
-          i.key  id
-          i.attr :name, name
-          i.attr :description, description
-        end
-
-        # Or to avoid name ties...
-        Lunar::Index.create self.class do |i|
-          i.key  id
-          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
-
-    # Searching...
-    # You can just straight out search keywords
-    Lunar.search(Item, "iphone")
-
-    # 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")
-    paginate @items, :per_page => 10, :page => 1
-
-    # If you want to be cheap about CPU cycles you can increase the
-    # default `:ttl` of search results (which is 30)
-
-    # Somewhere in config/initializers or init.rb, you decide...
-    Lunar.ttl = 300 # search results would be the same for 5 minutes.
-                    # for high write public sites, this may be a good
-                    # option as people don't really expect their stuff to
-                    # be searchable right away on public content sites.

data/examples/ohm.rb

@@ -1,40 +0,0 @@
-class Item < Ohm::Model
-  attribute :name
-  attribute :description
-
-  def index
-    Lunar::Index.create 'Item' do |i|
-      i.key  id
-      i.attr :name, name
-      i.attr :description, description
-    end
-    
-    # You can also do this, no problem
-    Lunar::Index.create Item do |i|
-      i.key  id
-      i.attr :name, name
-      i.attr :description, description
-    end
-
-    # Or to avoid name ties...
-    Lunar::Index.create self.class do |i|
-      i.key  id
-      i.attr :name, name
-      i.attr :description, description
-    end
-  end
-end
-
-# Searching...
-# You can just straight out search keywords
-Lunar.search(Item, "iphone")
-
-# Or opt to filter by field
-Lunar.search(Item, :name => "iphone", :description => "mobile")
-
-# Or search a field using an array
-Lunar.search(Item, :name => ["iphone", "apple"])
-
-# Or using the pagination gem with this:
-@items = Lunar.search(Item, "iphone")
-paginate @items, :per_page => 10, :page => 1

data/lib/lunar/search.rb

@@ -1,68 +0,0 @@
-module Lunar
-  class Search
-    attr :sets, :prefix, :search_identifier, :fuzzy_sets, :key_value_sets
-
-    def initialize(prefix, keywords)
-      if keywords.is_a?(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
-          @key_value_sets = 
-            keywords.map { |field, val| Sets.new(prefix, val, field) }.flatten
-
-          @search_identifier = keywords.hash
-        end
-      else
-        @sets = Sets.new(prefix, keywords)
-        @search_identifier = keywords.hash
-      end
-
-      @prefix = prefix
-
-      # Default finder, uses Ohm style finding
-      @finder = lambda { |id| prefix[id] }
-    end
-
-    def results(&block)
-      block ||= @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 key_value_sets
-        if key_value_sets.empty?
-          return []
-        else
-          Lunar.redis.zinter dist_key, key_value_sets.size, *key_value_sets
-          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
-  
-  protected
-    def dist_key
-      Lunar.nest[:Results][search_identifier]
-    end
-  end
-end
-

data/lib/lunar/sets.rb

@@ -1,86 +0,0 @@
-module Lunar
-  module Sets
-    def self.new(prefix, keywords, field = '*')
-      case keywords
-      when String
-        KeywordSets.new(prefix, keywords, field)
-      when Range
-        RangeSets.new(prefix, keywords, field)
-      when Array
-        KeywordSets.new(prefix, keywords.join(' '), field)
-      else
-        raise TypeError, ":keywords should only be a String or Range"
-      end
-    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
-
-    def initialize(prefix, range, field)
-      @prefix = prefix
-      @field  = field
-      @range  = range
-    
-      super [write_and_retrieve_key]
-    end
-    
-    def write_and_retrieve_key
-      zrange = Lunar.redis.zrangebyscore(Lunar.nest[prefix][field], 
-                                         @range.first, @range.last)
-
-      zrange.each { |id| Lunar.redis.zadd key, 1, id }
-      key.to_s
-    end
-
-    def key
-      @key ||= Lunar.nest[prefix][field]["#{ range.first }_TO_#{ range.last }"]
-    end
-  end
-
-  class KeywordSets < 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
-      keys_for_each_word.map { |key| Lunar.redis.keys(key) }.flatten
-    end
-
-    def keys_for_each_word
-      words.map { |w| ns[Lunar.encode(w)] }
-    end
-
-    def ns
-      @ns ||= Lunar.nest[prefix][field]
-    end
-  end
-end

data/test/test_lunar_fuzzy.rb

@@ -1,118 +0,0 @@
-# 
-# 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