lunar 0.4.1 → 0.5.0

data/.gitignore

@@ -19,4 +19,5 @@ rdoc
 pkg
 
 ## PROJECT::SPECIFIC
-.rvmrc
+/.yardoc
+/doc

data/LICENSE

@@ -17,4 +17,4 @@ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,116 @@
+Lunar: full text searching on top of Redis
+==========================================
+
+But why?
+--------
+We have been using Redis as our datastore exclusively for a lot of projects.
+But searching is still something that is required by most projects. Given
+those requirements and what we have, we could:
+
+1. Use SOLR and install it / manage it on every application we build.
+2. Use Sphinx (mind you we don't have MySQL running in our server too).
+3. Build our own (this appears to be something prevalent nowadays :D)
+
+Sphinx vs Lunar vs SOLR
+-----------------------
+SOLR is definitely the way to go if you have heavyweight searching requirements.
+Sphinx on the other hand, is probably an even match against Lunar.
+
+Features
+--------
+
+1. Full text search matching using metaphones.
+2. Ability to search by a specific field.
+3. Range matching for `number`s.
+4. Fuzzy matching for address book style autocompletion needs.
+
+Probably the most unique thing about Lunar is its Fuzzy matching
+capability. SOLR and Sphinx don't do this out of the box.
+
+Example
+-------
+Given you want to index a document with a `namespace` Gadget.
+
+    Lunar.index Gadget do |i|
+      i.text  :name, 'iphone 3gs'
+      i.text  :tags, 'mobile apple smartphone'
+
+      i.number :price, 200
+      i.number :rating, 25.5
+
+      i.sortable :votes, 50
+    end
+
+    #  with this declaration, you can now search:
+    Lunar.search Gadget, :q => 'iphone'
+    Lunar.search Gadget, :name => 'iphone', :tags => 'mobile'
+    Lunar.search Gadget, :price => 150..250
+
+    # If you need fuzzy matching you can also do that:
+    Lunar.index Customer do |i|
+      i.id 1001
+      i.fuzzy :name, "Abraham Lincoln"
+    end
+
+    Lunar.index Customer do |i|
+      i.id 1002
+      i.fuzzy :name, "Barack Obama"
+    end
+
+    Lunar.search Customer, :fuzzy => { :name => "A" }
+    # returns [Customer[1001]]
+
+    Lunar.search Customer, :fuzzy => { :name => "B" }
+    # returns [Customer[1002]]
+
+    # for sorting, you can do it on the `ResultSet` returned:
+    results = Lunar.search Gadget :q => 'iphone', :tags => 'mobile'
+    results.sort(:by => :votes, :order => "ASC")
+    results.sort(:by => :votes, :order => "DESC")
+
+    # this is also compatible with the pagination gem of course:
+    # let's say in our sinatra handler we do something like:
+
+    get '/gadget/search' do
+      @gadgets = paginate(Lunar.search(Gadget, :q => params[:q]),
+        :per_page => 10, :page => params[:page],
+        :sort_by => :votes, :order => 'DESC'
+      )
+    end
+
+    # see http://github.com/sinefunc/pagination for more info.
+
+Under the Hood?
+---------------
+A quick rundown of what happens when we do fulltext indexing:
+
+    Lunar.index :Gadget do |i|
+      i.id 1001
+      i.text :title, "apple apple apple macbook macbook pro"
+    end
+
+    # Executes the ff: in redis:
+    #
+    # ZADD Lunar:Gadget:title:APL  3 1001
+    # ZADD Lunar:Gadget:title:MKBK 2 1001
+    # ZADD Lunar:Gadget:title:PR   1 1001
+    #
+    # In addition a reference of all the words are stored
+    # SMEMBERS Lunar:Gadget:Metaphones:1001:title
+    # => (APL, MKBK, PR)
+
+Note on Patches/Pull Requests
+-----------------------------
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a
+  commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+### Copyright
+
+Copyright (c) 2010 Cyril David. See LICENSE for details.

data/Rakefile

@@ -5,14 +5,15 @@ begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
     gem.name = "lunar"
-    gem.summary = %Q{a minimalistic full text search implementation in redis}
-    gem.description = %Q{uses sorted sets and sets, sorting by score}
+    gem.summary = %Q{A redis based full text search engine}
+    gem.description = %Q{Features full text searching via metaphones, range querying for numbers, fuzzy searching and sorting based on customer fields}
     gem.email = "cyx.ucron@gmail.com"
     gem.homepage = "http://github.com/sinefunc/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
+    gem.add_dependency "redis", ">= 2.0.0"
+    gem.add_dependency "nest", ">= 0.0.4"
+    gem.add_dependency "text", ">= 0"
+    gem.add_development_dependency "contest", ">= 0"
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError

data/VERSION

@@ -1 +1 @@
-0.4.1
+0.5.0

data/lib/lunar.rb

@@ -1,39 +1,127 @@
 require 'base64'
-require File.join(File.dirname(__FILE__), '..', 'vendor', 'nest', 'nest')
+require 'redis'
+require 'nest'
+require 'text'
 
 module Lunar
-  autoload :Scoring,           'lunar/scoring'
-  autoload :Index,             'lunar/index'
-  autoload :Words,             'lunar/words'
-  autoload :Search,            'lunar/search'
-  autoload :Sets,              'lunar/sets'
-  autoload :FuzzySets,         'lunar/sets'
-  autoload :SortedResultSet,   'lunar/result_set'
-  autoload :UnsortedResultSet, 'lunar/result_set'
-  autoload :FuzzyWord,         'lunar/fuzzy_word'
-  
-  def self.ttl
-    @ttl ||= 30
+  VERSION = '0.5.0'
+
+  autoload :Connection,     "lunar/connection"
+  autoload :LunarNest,      "lunar/lunar_nest"
+  autoload :Index,          "lunar/index"
+  autoload :Scoring,        "lunar/scoring"
+  autoload :Words,          "lunar/words"
+  autoload :Stopwords,      "lunar/stopwords"
+  autoload :FuzzyWord,      "lunar/fuzzy_word"
+  autoload :KeywordMatches, "lunar/keyword_matches"
+  autoload :RangeMatches,   "lunar/range_matches"
+  autoload :FuzzyMatches,   "lunar/fuzzy_matches"
+  autoload :ResultSet,      "lunar/result_set"
+
+  extend Connection
+
+  # Index any document using a namespace. The namespace can
+  # be a class, or a plain Symbol/String.
+  #
+  # @example:
+  #
+  #   Lunar.index Gadget do |i|
+  #     i.text  :name, 'iphone 3gs'
+  #     i.text  :tags, 'mobile apple smartphone'
+  #
+  #     i.number :price, 200
+  #     i.number :rating, 25.5
+  #
+  #     i.sortable :votes, 50
+  #   end
+  #
+  # @see Lunar::Index#initialize
+  # @param [String, Symbol, Class] namespace the namespace if this document.
+  # @yield [Lunar::Index] an instance of Lunar::Index.
+  # @return [Lunar::Index] returns the yielded Lunar::Index.
+  def self.index(namespace)
+    Index.new(namespace).tap { |i| yield i }
   end
 
-  def self.ttl=(ttl)
-    @ttl = ttl
+  # Delete a document identified by its namespace and id.
+  #
+  # @param [#to_s] namespace the namespace of the document to delete.
+  # @param [#to_s] id the id of the document to delete.
+  # @return [nil]
+  def self.delete(namespace, id)
+    Index.new(namespace).delete(id)
   end
 
-  def self.redis(connection = defined?(Ohm) ? Ohm.redis : nil)
-    @connection ||= connection 
+  # Search for a document, scoped under a namespace.
+  #
+  # @example:
+  #
+  #   Lunar.search Gadget, :q => "apple"
+  #   # returns all gadgets with `text` apple.
+  #
+  #   Lunar.search Gadget, :q => "apple", :description => "cool"
+  #   # returns all gadgets with `text` apple and description:cool
+  #
+  #   Lunar.search Gadget, :q => "phone", :price => 200..250
+  #   # returns all gadgets with `text` phone priced between 200 to 250
+  #
+  #   Lunar.search Customer, :fuzzy => { :name => "ad" }
+  #   # returns all customers with their first / last name beginning with 'ad'
+  #
+  #   Lunar.search Customer, :fuzzy => { :name => "ad" }, :age => 20..25
+  #   # returns all customers with name starting with 'ad' aged 20 to 25.
+  #
+  # @param [#to_s] namespace search under which scope e.g. Gadget
+  # @param [Hash] options i.e. :q, :field1, :field2, :fuzzy
+  # @option options [Symbol] :q keywords e.g. `apple iphone 3g`
+  # @option options [Symbol] :field1 any field you indexed and a value
+  # @option options [Symbol] :fuzzy hash of :key => :value pairs
+  # @param [#to_proc] finder (optional) for cases where `Gadget[1]` isn't the
+  #   method of finding. You can for example use an ActiveRecord model and
+  #   pass in lambda { |id| Gadget.find(id) }.
+  #
+  # @return Lunar::ResultSet an Enumerable object.
+  def self.search(namespace, options, finder = lambda { |id| namespace[id] })
+    ns = nest[namespace]
+
+    sets =
+      options.map do |key, value|
+        if value.is_a?(Range)
+          RangeMatches.new(nest[namespace], key, value).distkey
+        elsif key == :fuzzy
+          value.map do |fuzzy_key, fuzzy_value|
+            FuzzyMatches.new(nest[namespace], fuzzy_key, fuzzy_value).distkey
+          end
+        else
+          KeywordMatches.new(nest[namespace], key, value).distkey
+        end
+      end
+
+    sets = sets.flatten
+
+    key =
+      if sets.size == 1
+        sets.first
+      else
+        ns[options.hash].zinterstore sets
+        ns[options.hash]
+      end
+
+    ResultSet.new(key, ns, finder)
   end
 
-  def self.search(prefix, keywords, &block)
-    search = Search.new(prefix, keywords)
-    search.results(&block)
+  # @private internally used for determining the metaphone of a word.
+  def self.metaphone(word)
+    Text::Metaphone.metaphone(word)
   end
 
-  def self.encode(str)
-    Base64.encode64(str).strip 
+  # @private abstraction of how encoding should be done for Lunar.
+  def self.encode(word)
+    Base64.encode64(word).strip
   end
 
+  # @private convenience method for getting a scoped Nest.
   def self.nest
-    Nest.new(:Lunar)
+    LunarNest.new(:Lunar, redis)
   end
-end
+end

data/lib/lunar/connection.rb

@@ -0,0 +1,51 @@
+module Lunar
+  module Connection
+    # Connect to a redis database.
+    #
+    # @param options [Hash] options to create a message with.
+    # @option options [#to_s] :host ('127.0.0.1') Host of the redis database.
+    # @option options [#to_s] :port (6379) Port number.
+    # @option options [#to_s] :db (0) Database number.
+    # @option options [#to_s] :timeout (0) Database timeout in seconds.
+    # @example Connect to a database in port 6380.
+    #   Lunar.connect(:port => 6380)
+    def connect(*options)
+      self.redis = nil
+      @options = options
+    end
+
+    # @private Provides access to the Redis database. This is shared accross all
+    # models and instances.
+    #
+    # @return [Redis] an instance of Redis
+    def redis
+      threaded[:redis] ||= connection(*options)
+    end
+
+    # @private Set the Redis database connection
+    # @param [Redis] connection the redis connection
+    def redis=(connection)
+      threaded[:redis] = connection
+    end
+
+  private
+    # @private internally used for connection thread saftey
+    def threaded
+      Thread.current[:lunar] ||= {}
+    end
+
+    # @private Return a connection to Redis.
+    #
+    # This is a wapper around Redis.new(options)
+    def connection(*options)
+      Redis.new(*options)
+    end
+
+    # @private Return a connection to Redis.
+    #
+    # stores the connection options. used by Lunar::Connection::connect
+    def options
+      @options || []
+    end
+  end
+end

data/lib/lunar/fuzzy_matches.rb

@@ -0,0 +1,24 @@
+module Lunar
+  # @private Used internally by Lunar::search to get all the fuzzy matches
+  # given `nest`, `att` and it's `val`.
+  class FuzzyMatches
+    attr :nest
+    attr :att
+    attr :value
+
+    def initialize(nest, att, value)
+      @nest, @att, @value = nest, att.to_sym, value
+    end
+
+    def distkey
+      nest[{ att => value }.hash].tap do |dk|
+        dk.zunionstore keys.flatten
+      end
+    end
+
+  protected
+    def keys
+      Words.new(value).map { |w| nest[:Fuzzies][att][Lunar.encode(w)] }
+    end
+  end
+end

data/lib/lunar/fuzzy_word.rb

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

data/lib/lunar/index.rb

@@ -1,136 +1,242 @@
 module Lunar
+  # Handles the management of indices for a given namespace.
+  # Although you may use this directly, it's much more convenient
+  # to use `Lunar::index` and `Lunar::delete`.
+  #
+  # @see Lunar::index
+  # @see Lunar::delete
   class Index
     FUZZY_MAX_LENGTH = 100
 
+    MissingID = Class.new(StandardError)
     FuzzyFieldTooLong = Class.new(StandardError)
 
-    attr :ns
-  
-    def self.create(prefix)
-      new(prefix).tap { |i| yield i }.index
+    attr :nest
+    attr :metaphones
+    attr :numbers
+    attr :sortables
+    attr :fuzzies
+
+    # This is actually wrapped by `Lunar.index` and is not inteded to be
+    # used directly.
+    # @see Lunar::index
+    # @param [#to_s] the namespace of the document you want to index.
+    # @return [Lunar::Index]
+    def initialize(namespace)
+      @nest       = Lunar.nest[namespace]
+      @metaphones = @nest[:Metaphones]
+      @numbers    = @nest[:Numbers]
+      @sortables  = @nest[:Sortables]
+      @fuzzies    = @nest[:Fuzzies]
     end
 
-    def self.delete(prefix, key)
-      new(prefix).tap { |i| i.key key }.delete 
+    # Get / Set the id of the document
+    # @example:
+    #
+    #   # Wrong usage:
+    #   Lunar.index :Gadget do |i|
+    #     i.text :name, 'iPad'
+    #   end
+    #   # => raise MissingID
+    #
+    #   # Correct usage:
+    #   Lunar.index :Gadget do |i|
+    #     i.id 1001 # this appears before anything.
+    #     i.text :name, 'iPad' # ok now you can set other fields.
+    #   end
+    #
+    # The `id` is used for all other keys to define the structure of the
+    # keys, therefore it's imperative that you set it first.
+    #
+    # @param [#to_s] the id of the document you want to index.
+    # @raise [Lunar::Index::MissingID] when you access without setting it first
+    # @return [String] the `id` you set.
+    def id(value = nil)
+      @id = value.to_s if value
+      @id or raise MissingID, "In order to index a document, you need an `id`"
     end
 
-    def initialize(prefix, redis = nil)
-      @ns    = Lunar.nest[prefix]
-      @attrs = {}
-      @redis = (redis || Lunar.redis)
-      @numeric_attrs = {}
-      @fuzzy_attrs = {}
-    end
+    # Indexes all the metaphone equivalents of the words
+    # in value except for words included in Stopwords.
+    #
+    # @example
+    #
+    #   Lunar.index :Gadget do |i|
+    #     i.id 1001
+    #     i.text :title, "apple macbook pro"
+    #   end
+    #
+    #   # Executes the ff: in redis:
+    #   #
+    #   # ZADD Lunar:Gadget:title:APL  1 1001
+    #   # ZADD Lunar:Gadget:title:MKBK 1 1001
+    #   # ZADD Lunar:Gadget:title:PR   1 1001
+    #   #
+    #   # In addition a reference of all the words are stored
+    #   # SMEMBERS Lunar:Gadget:Metaphones:1001:title
+    #   # => (APL, MKBK, PR)
+    #
+    # @param [Symbol] att the field name in your document
+    # @param [String] value the content of the field name
+    #
+    # @return [Array<String>] all the metaphones added for the document.
+    def text(att, value)
+      old = metaphones[id][att].smembers
+      new = []
+
+      Scoring.new(value).scores.each do |word, score|
+        metaphone = Lunar.metaphone(word)
+
+        nest[att][metaphone].zadd(score, id)
+        metaphones[id][att].sadd(metaphone)
+        new << metaphone
+      end
 
-    def key(key = nil)
-      @key = key if key
-      @key
-    end
+      (old - new).each do |metaphone|
+        nest[att][metaphone].zrem(id)
+        metaphones[id][att].srem(metaphone)
+      end
 
-    def attrs=(attrs)
-      attrs.each { |k, v| attr k, v } 
+      return new
     end
 
-    def attr(field, value = nil)
-      @attrs[field.to_sym] = value if value
-      @attrs[field.to_sym]
+    # Adds a numeric index for `att` with `value`.
+    #
+    # @example
+    #
+    #   Lunar.index :Gadget do |i|
+    #     i.id 1001
+    #     i.number :price, 200
+    #   end
+    #
+    #   # Executes the ff: in redis:
+    #   #
+    #   # ZADD Lunar:Gadget:price 200
+    #
+    # @param [Symbol] att the field name in your document.
+    # @param [Numeric] value the numeric value of `att`.
+    #
+    # @return [Boolean] whether or not the value was added
+    def number(att, value)
+      numbers[att].zadd(value, id)
     end
 
-    def numeric_attr(field, value = nil)
-      @numeric_attrs[field.to_sym] = value if value
-      @numeric_attrs[field.to_sym]
+    # Adds a sortable index for `att` with `value`.
+    #
+    # @example
+    #
+    #   class Gadget
+    #     def self.[](id)
+    #       # find the gadget using id here
+    #     end
+    #   end
+    #
+    #   Lunar.index Gadget do |i|
+    #     i.id 1001
+    #     i.text 'apple macbook pro'
+    #     i.sortable :votes, 50
+    #   end
+    #
+    #   Lunar.index Gadget do |i|
+    #     i.id 1002
+    #     i.text 'apple iphone 3g'
+    #     i.sortable :votes, 20
+    #   end
+    #
+    #   results = Lunar.search(Gadget, :q => 'apple')
+    #   results.sort(:by => :votes, :order => 'DESC')
+    #   # returns [Gadget[1001], Gadget[1002]]
+    #
+    #   results.sort(:by => :votes, :order => 'ASC')
+    #   # returns [Gadget[1002], Gadget[1001]]
+    #
+    # @param [Symbol] att the field you want to have sortability.
+    # @param [String, Numeric] value the value of the sortable field.
+    #
+    # @return [String] the response from the redis server.
+    def sortable(att, value)
+      sortables[id][att].set(value)
     end
-    alias :integer :numeric_attr
-    alias :float   :numeric_attr
 
-    def fuzzy(field, value = nil)
-      @fuzzy_attrs[field.to_sym] = value if value
-      @fuzzy_attrs
+    # Deletes everything related to an existing document given its `id`.
+    #
+    # @param [#to_s] id the document's id.
+    # @return [nil]
+    def delete(existing_id)
+      id(existing_id)
+      delete_metaphones
+      delete_numbers
+      delete_sortables
+      delete_fuzzies
     end
 
-    def index
-      index_str_attrs
-      index_fuzzy_attrs
-      index_numeric_attrs
+    def fuzzy(att, value)
+      if value.to_s.length > FUZZY_MAX_LENGTH
+        raise FuzzyFieldTooLong,
+          "#{att} has a value #{value} exceeding the max #{FUZZY_MAX_LENGTH}"
+      end
 
-      return self
-    end
+      words = Words.new(value).uniq
 
-    def delete
-      keys = @redis.keys @ns[key]['*']
-      keys.each do |k|
-        field = k.gsub("#{ @ns[key] }:", '')
-        words = @redis.smembers(k)
-        words.each do |w|
-          @redis.zrem @ns[field][Lunar.encode(w)], key
+      fuzzy_words_and_parts(words) do |word, parts|
+        parts.each do |part, encoded|
+          fuzzies[att][encoded].zadd(1, id)
         end
-        @redis.del k
+        fuzzies[id][att].sadd word
       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
+      delete_fuzzies_for(att, fuzzies[id][att].smembers - words, words)
     end
 
-  protected
-    def index_str_attrs
-      @attrs.each do |field, value|
-        scoring = Scoring.new(value)
-        words   = []
-        scoring.scores.each do |word, score|
-          words << word
-          @redis.zadd @ns[field][Lunar.encode(word)], score, key
-          @redis.sadd @ns[key][field], word
+  private
+    def delete_metaphones
+      metaphones[id]['*'].matches.each do |key, att|
+        key.smembers.each do |metaphone|
+          nest[att][metaphone].zrem id
         end
 
-        unused_words = @redis.smembers(@ns[key][field]) - words
-        unused_words.each do |word|
-          @redis.zrem @ns[field][Lunar.encode(word)], key
-          @redis.srem @ns[key][field], word
-        end
+        key.del
       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
+    def delete_numbers
+      numbers['*'].matches.each do |key, att|
+        numbers[att].zrem(id)
+      end
+    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
+    def delete_sortables
+      sortables[id]['*'].keys.each do |key|
+        Lunar.redis.del key
+      end
+    end
+
+    def delete_fuzzies
+      fuzzies[id]['*'].matches.each do |key, att|
+        delete_fuzzies_for(att, key.smembers)
+        key.del
       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
+
+    def delete_fuzzies_for(att, words_to_delete, existing_words = [])
+      fuzzy_words_and_parts(words_to_delete) do |word, parts|
+        parts.each do |part, encoded|
+          next if existing_words.grep(/^#{part}/u).any?
+          fuzzies[att][encoded].zrem(id)
         end
-        @redis.srem @ns[:Fuzzy][key][field], word
+        fuzzies[id][att].srem word
       end
     end
 
-    def index_numeric_attrs
-      @numeric_attrs.each do |field, value|
-        @redis.zadd @ns[field], value, key
+    def fuzzy_words_and_parts(words)
+      words.each do |word|
+        partials =
+          FuzzyWord.new(word).partials.map do |partial|
+            [partial, Lunar.encode(partial)]
+          end
+
+        yield word, partials
       end
     end
   end
-end
+end