lunar 0.4.1 → 0.5.0

data/test/test_index.rb

@@ -0,0 +1,150 @@
+require "helper"
+
+class IndexTest < Test::Unit::TestCase
+  class Gadget < Struct.new(:id)
+  end
+
+  describe "indexing texts" do
+    def nest(word)
+      Lunar.nest[:Gadget][:title][Lunar.metaphone(word)]
+    end
+
+    test "with non-repeating words" do
+      ret = Lunar.index :Gadget do |i|
+        i.id 1001
+        i.text :title, 'apple iphone 3GS smartphone'
+      end
+
+      assert_equal ['1001'], nest('apple').zrangebyscore(1, 1)
+      assert_equal ['1001'], nest('iphone').zrangebyscore(1, 1)
+      assert_equal ['1001'], nest('3gs').zrangebyscore(1, 1)
+      assert_equal ['1001'], nest('smartphone').zrangebyscore(1, 1)
+
+      assert_equal %w{APL IFN KS SMRTFN},
+        Lunar.nest[:Gadget][:Metaphones][1001][:title].smembers.sort
+    end
+
+    test "deleting non-repeating words scenario" do
+      ret = Lunar.index :Gadget do |i|
+        i.id 1001
+        i.text :title, 'apple iphone 3GS smartphone'
+      end
+
+      Lunar.delete(:Gadget, 1001)
+
+      assert_equal 0, nest('apple').zcard
+      assert_equal 0, nest('iphone').zcard
+      assert_equal 0, nest('3gs').zcard
+      assert_equal 0, nest('smartphone').zcard
+
+      assert_equal 0, Lunar.nest[:Gadget][1001][:title].scard
+    end
+
+    test "with multiple word instances and stopwords" do
+      Lunar.index :Gadget do |i|
+        i.id 1001
+        i.text :title, 'count of monte cristo will count to 100'
+      end
+
+      assert_equal ['1001'], nest('count').zrangebyscore(2, 2)
+      assert_equal ['1001'], nest('monte').zrangebyscore(1, 1)
+      assert_equal ['1001'], nest('cristo').zrangebyscore(1, 1)
+      assert_equal ['1001'], nest('100').zrangebyscore(1, 1)
+
+      assert nest('of').zrange(0, -1).empty?
+      assert nest('to').zrange(0, -1).empty?
+      assert nest('will').zrange(0, -1).empty?
+    end
+
+    test "deleting multiple word instances scenario" do
+      Lunar.index :Gadget do |i|
+        i.id 1001
+        i.text :title, 'count of monte cristo will count to 100'
+      end
+
+      Lunar.delete(:Gadget, 1001)
+
+      assert_equal 0, nest('count').zcard
+      assert_equal 0, nest('monte').zcard
+      assert_equal 0, nest('cristo').zcard
+      assert_equal 0, nest('100').zcard
+
+      assert_nil Lunar.nest[:Gadget][1001][:title].get
+    end
+
+    test "re-indexing" do
+      Lunar.index :Gadget do |i|
+        i.id 1001
+        i.text :title, 'apple iphone 3GS smartphone'
+      end
+
+      Lunar.index :Gadget do |i|
+        i.id 1001
+        i.text :title, 'apple iphone 3G'
+      end
+
+      assert_equal ['1001'], nest('apple').zrangebyscore(1, 1)
+      assert_equal ['1001'], nest('iphone').zrangebyscore(1, 1)
+      assert_equal ['1001'], nest('3g').zrangebyscore(1, 1)
+
+      assert nest('3gs').zrange(0, -1).empty?
+      assert nest('smartphone').zrange(0, -1).empty?
+    end
+  end
+
+  describe "indexing numbers" do
+    test "works for integers and floats" do
+      Lunar.index :Gadget do |i|
+        i.id 1001
+        i.number :price, 200
+        i.number :score, 25.5
+      end
+
+      assert_equal '200',  Lunar.nest[:Gadget][:Numbers][:price].zscore(1001)
+      assert_equal '25.5', Lunar.nest[:Gadget][:Numbers][:score].zscore(1001)
+    end
+
+    test "allows deletion" do
+      Lunar.index :Gadget do |i|
+        i.id 1001
+        i.number :price, 200
+        i.number :score, 25.5
+      end
+
+      Lunar.delete :Gadget, 1001
+
+      assert_nil Lunar.nest[:Gadget][:Numbers][:price].zrank(1001)
+      assert_nil Lunar.nest[:Gadget][:Numbers][:score].zrank(1001)
+    end
+  end
+
+  describe "sortable fields" do
+    test "works for integers, floats, strings" do
+      Lunar.index :Gadget do |i|
+        i.id 1001
+        i.sortable :name, 'iphone'
+        i.sortable :price, 200
+        i.sortable :score, 25.5
+      end
+
+      assert_equal 'iphone', Lunar.nest[:Gadget][:Sortables][1001][:name].get
+      assert_equal '200',    Lunar.nest[:Gadget][:Sortables][1001][:price].get
+      assert_equal '25.5',   Lunar.nest[:Gadget][:Sortables][1001][:score].get
+    end
+
+    test "deletes sortable fields" do
+      Lunar.index :Gadget do |i|
+        i.id 1001
+        i.sortable :name, 'iphone'
+        i.sortable :price, 200
+        i.sortable :score, 25.5
+      end
+
+      Lunar.delete :Gadget, 1001
+
+      assert_nil Lunar.nest[:Gadget][1001][:name].get
+      assert_nil Lunar.nest[:Gadget][1001][:price].get
+      assert_nil Lunar.nest[:Gadget][1001][:score].get
+    end
+  end
+end

data/test/test_lunar.rb

@@ -1,4 +1,181 @@
 require 'helper'
 
 class TestLunar < Test::Unit::TestCase
-end
+  class Gadget < Struct.new(:id)
+    def self.[](id)
+      new(id)
+    end
+  end
+
+  context "an index of some gadgets" do
+    setup do
+      Lunar.index Gadget do |i|
+        i.id 1001
+        i.text   :title, 'apple iphone 3GS smartphone'
+        i.text   :tags, 'mobile smartphone apple'
+        i.number :price, 200
+        i.number :score, 35.5
+        i.fuzzy  :code, 'apple iphone mobile'
+
+        i.sortable :price, 200
+        i.sortable :score, 35.5
+        i.sortable :title, 'apple iphone 3GS'
+      end
+
+      Lunar.index Gadget do |i|
+        i.id 1002
+        i.text   :title, 'nokia N95 Symbian smartphone'
+        i.text   :tags,  'mobile smartphone nokia'
+        i.number :price, 150
+        i.number :score, 20.5
+        i.fuzzy  :code,  'nokia n95 mobile'
+
+        i.sortable :price, 150
+        i.sortable :score, 20.5
+        i.sortable :title, 'nokia N95 Symbian smartphone'
+      end
+
+      Lunar.index Gadget do |i|
+        i.id 1003
+        i.text   :title, 'blackberry bold 9000 smartphone'
+        i.text   :tags, 'mobile smartphone blackberry'
+        i.number :price, 170
+        i.number :score, 25.5
+        i.fuzzy  :code,  'blackberry bold mobile'
+
+        i.sortable :price, 170
+        i.sortable :score, 25.5
+        i.sortable :title, 'blackberry bold 9000 smartphone'
+      end
+    end
+
+    def q(options)
+      Lunar.search(Gadget, options).map(&:id)
+    end
+
+    test "all kinds of fulltext searching" do
+      assert_equal %w{1001}, q(:q => 'apple')
+      assert_equal %w{1001}, q(:q => 'iphone')
+      assert_equal %w{1001}, q(:q => '3gs')
+      assert_equal %w{1001 1002 1003}, q(:q => 'smartphone')
+      assert_equal %w{1001 1002 1003}, q(:q => 'mobile')
+      assert_equal %w{1002}, q(:q => 'nokia')
+      assert_equal %w{1002}, q(:q => 'n95')
+      assert_equal %w{1002}, q(:q => 'symbian')
+      assert_equal %w{1003}, q(:q => 'blackberry')
+      assert_equal %w{1003}, q(:q => 'bold')
+      assert_equal %w{1003}, q(:q => '9000')
+    end
+
+    test "fulltext searching with key value pairs" do
+      assert_equal %w{1001}, q(:q => 'apple', :tags => 'mobile')
+      assert_equal %w{1001}, q(:q => 'apple', :tags => 'smartphone')
+      assert_equal %w{1001}, q(:q => 'apple', :tags => 'apple')
+
+      assert_equal %w{1001 1002 1003}, q(:q => 'mobile', :tags => 'smartphone')
+    end
+
+    test "fulltext + keyword searching with range matching" do
+      assert_equal %w{1001}, q(:q => 'mobile', :tags => 'smartphone', :price => 200..200)
+      assert_equal %w{1002}, q(:q => 'mobile', :tags => 'smartphone', :price => 150..150)
+      assert_equal %w{1003}, q(:q => 'mobile', :tags => 'smartphone', :price => 170..170)
+
+      assert_equal %w{1001 1002 1003}, q(:price => 150..200)
+    end
+
+    test "searching one key => value pair" do
+      assert_equal %w{1001}, q(:title => 'apple')
+      assert_equal %w{1001}, q(:title => 'iphone')
+      assert_equal %w{1001}, q(:title => '3GS')
+      assert_equal %w{1001 1002 1003}, q(:title => 'smartphone')
+    end
+
+    test "searching multiple key => value pairs" do
+      assert_equal %w{1001}, q(:title => 'apple', :tags => 'mobile')
+      assert_equal %w{1001}, q(:title => 'apple', :tags => 'smartphone')
+      assert_equal %w{1001}, q(:title => 'apple', :tags => 'apple')
+
+      assert_equal %w{1001 1002 1003}, q(:title => 'smartphone', :tags => 'mobile')
+      assert_equal %w{1001 1002 1003}, q(:title => 'smartphone', :tags => 'smartphone')
+      assert_equal %w{1001}, q(:title => 'smartphone', :tags => 'apple')
+    end
+
+    test "sorting by price" do
+      r = Lunar.search(Gadget, :q => 'smartphone').sort_by(:price, :order => 'ASC')
+      assert_equal %w{1002 1003 1001}, r.map(&:id)
+
+      r = Lunar.search(Gadget, :q => 'smartphone').sort_by(:price, :order => 'DESC')
+      assert_equal %w{1001 1003 1002}, r.map(&:id)
+
+      r = Lunar.search(Gadget, :q => 'smartphone').sort(:by => :price, :order => 'ASC')
+      assert_equal %w{1002 1003 1001}, r.map(&:id)
+
+      r = Lunar.search(Gadget, :q => 'smartphone').sort(:by => :price, :order => 'DESC')
+      assert_equal %w{1001 1003 1002}, r.map(&:id)
+    end
+
+    test "sorting by score" do
+      r = Lunar.search(Gadget, :q => 'smartphone').sort_by(:score, :order => 'ASC')
+      assert_equal %w{1002 1003 1001}, r.map(&:id)
+
+      r = Lunar.search(Gadget, :q => 'smartphone').sort_by(:score, :order => 'DESC')
+      assert_equal %w{1001 1003 1002}, r.map(&:id)
+
+      r = Lunar.search(Gadget, :q => 'smartphone').sort(:by => :score, :order => 'ASC')
+      assert_equal %w{1002 1003 1001}, r.map(&:id)
+
+      r = Lunar.search(Gadget, :q => 'smartphone').sort(:by => :score, :order => 'DESC')
+      assert_equal %w{1001 1003 1002}, r.map(&:id)
+    end
+
+    test "sorting by title" do
+      r = Lunar.search(Gadget, :q => 'smartphone').sort_by(:title, :order => 'ALPHA ASC')
+      assert_equal %w{1001 1003 1002}, r.map(&:id)
+
+      r = Lunar.search(Gadget, :q => 'smartphone').sort_by(:title, :order => 'ALPHA DESC')
+      assert_equal %w{1002 1003 1001}, r.map(&:id)
+
+      r = Lunar.search(Gadget, :q => 'smartphone').sort(:by => :title, :order => 'ALPHA ASC')
+      assert_equal %w{1001 1003 1002}, r.map(&:id)
+
+      r = Lunar.search(Gadget, :q => 'smartphone').sort(:by => :title, :order => 'ALPHA DESC')
+      assert_equal %w{1002 1003 1001}, r.map(&:id)
+    end
+
+    test "fuzzy matching on code apple iphone" do
+      assert_equal %w{1001}, q(:fuzzy => { :code => 'a' })
+      assert_equal %w{1001}, q(:fuzzy => { :code => 'ap' })
+      assert_equal %w{1001}, q(:fuzzy => { :code => 'app' })
+      assert_equal %w{1001}, q(:fuzzy => { :code => 'appl' })
+      assert_equal %w{1001}, q(:fuzzy => { :code => 'apple' })
+
+      assert_equal %w{1001}, q(:fuzzy => { :code => 'i' })
+      assert_equal %w{1001}, q(:fuzzy => { :code => 'ip' })
+      assert_equal %w{1001}, q(:fuzzy => { :code => 'iph' })
+      assert_equal %w{1001}, q(:fuzzy => { :code => 'ipho' })
+      assert_equal %w{1001}, q(:fuzzy => { :code => 'iphon' })
+      assert_equal %w{1001}, q(:fuzzy => { :code => 'iphone' })
+
+      assert_equal %w{1001}, q(:fuzzy => { :code => 'a i' })
+      assert_equal %w{1001}, q(:fuzzy => { :code => 'app iph' })
+    end
+
+    test "fuzzy matching on code mobile" do
+      assert_equal %w{1001 1002 1003}, q(:fuzzy => { :code => 'm' })
+      assert_equal %w{1001 1002 1003}, q(:fuzzy => { :code => 'mo' })
+      assert_equal %w{1001 1002 1003}, q(:fuzzy => { :code => 'mob' })
+      assert_equal %w{1001 1002 1003}, q(:fuzzy => { :code => 'mobi' })
+      assert_equal %w{1001 1002 1003}, q(:fuzzy => { :code => 'mobil' })
+      assert_equal %w{1001 1002 1003}, q(:fuzzy => { :code => 'mobile' })
+    end
+
+    test "fuzzy matching on code mobile with keywords: apple" do
+      assert_equal %w{1001}, q(:q => 'apple', :fuzzy => { :code => 'm' })
+      assert_equal %w{1001}, q(:q => 'apple', :fuzzy => { :code => 'mo' })
+      assert_equal %w{1001}, q(:q => 'apple', :fuzzy => { :code => 'mob' })
+      assert_equal %w{1001}, q(:q => 'apple', :fuzzy => { :code => 'mobi' })
+      assert_equal %w{1001}, q(:q => 'apple', :fuzzy => { :code => 'mobil' })
+      assert_equal %w{1001}, q(:q => 'apple', :fuzzy => { :code => 'mobile' })
+    end
+  end
+end

data/test/test_lunar_fuzzy_word.rb

@@ -5,10 +5,10 @@ class LunarFuzzyWordTest < Test::Unit::TestCase
     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    
+      assert_equal ['d', 'di', 'dic', 'dict', 'dicti', 'dictio',
+        'diction', 'dictiona', 'dictionar', 'dictionary'], @w.partials
     end
   end
-end
+end

data/test/test_lunar_nest.rb

@@ -0,0 +1,46 @@
+require "helper"
+
+class LunarNestTest < Test::Unit::TestCase
+  test "retrieving keys for a pattern" do
+    Lunar.redis.set("Foo:1:Bar", 1)
+    Lunar.redis.set("Foo:2:Bar", 2)
+
+    nest = Lunar::LunarNest.new("Foo", Lunar.redis)['*']["Bar"]
+
+    assert_equal ['Foo:1:Bar', 'Foo:2:Bar'], nest.keys.sort
+  end
+
+  test "retrieving keys and their matches" do
+    Lunar.redis.set("Foo:1:Bar", 1)
+    Lunar.redis.set("Foo:2:Bar", 2)
+
+    nest = Lunar::LunarNest.new("Foo", Lunar.redis)['*']["Bar"]
+
+    matches = []
+
+    nest.matches.each do |key, m|
+      matches << m
+    end
+
+    assert_equal ['1', '2'], matches.sort
+  end
+
+  test "retrieving keys and their matches when more than one *" do
+    Lunar.redis.set("Foo:1:Bar:3:Baz", 1)
+    Lunar.redis.set("Foo:2:Bar:4:Baz", 2)
+
+    nest = Lunar::LunarNest.new("Foo", Lunar.redis)['*']["Bar"]["*"]["Baz"]
+
+    matches1 = []
+    matches2 = []
+
+    nest.matches.each do |key, m1, m2|
+      matches1 << m1
+      matches2 << m2
+    end
+
+    assert_equal ['1', '2'], matches1.sort
+    assert_equal ['3', '4'], matches2.sort
+  end
+
+end

data/test/{test_lunar_scoring.rb → test_scoring.rb}

@@ -1,10 +1,10 @@
-require "helper"
+require 'helper'
 
 class LunarScoringTest < Test::Unit::TestCase
   describe "scores of 'the quick brown fox jumps over the lazy dog'" do
     should "return a hash of the words with score 1 except the, with score 2" do
       scoring = Lunar::Scoring.new("the quick brown fox jumps over the lazy dog")
-      assert_equal 2, scoring.scores["the"]
+      assert_equal 0, scoring.scores["the"]
       assert_equal 1, scoring.scores["quick"]
       assert_equal 1, scoring.scores["brown"]
       assert_equal 1, scoring.scores["fox"]
@@ -18,10 +18,10 @@ class LunarScoringTest < Test::Unit::TestCase
   describe "scores of 'tHe qUick bRowN the quick brown THE QUICK BROWN'" do
     should "return a hash of each of the words the quick brown with score 3" do
       scoring = Lunar::Scoring.new('tHe qUick bRowN the quick brown THE QUICK BROWN')
-      assert_equal 3, scoring.scores['the']
+      assert_equal 0, scoring.scores['the']
       assert_equal 3, scoring.scores['quick']
       assert_equal 3, scoring.scores['brown']
-    end     
+    end
   end
 
   describe 'scores of apple macbook pro 17"' do
@@ -33,4 +33,4 @@ class LunarScoringTest < Test::Unit::TestCase
       assert_equal 1, scoring.scores['17']
     end
   end
-end
+end

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: lunar
 version: !ruby/object:Gem::Version 
-  version: 0.4.1
+  prerelease: false
+  segments: 
+  - 0
+  - 5
+  - 0
+  version: 0.5.0
 platform: ruby
 authors: 
 - Cyril David
@@ -9,30 +14,62 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-20 00:00:00 +08:00
+date: 2010-05-21 00:00:00 +08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: contest
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  name: redis
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 0
+        - 0
+        version: 2.0.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: nest
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 0
+        - 4
+        version: 0.0.4
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: text
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
         version: "0"
-    version: 
+  type: :runtime
+  version_requirements: *id003
 - !ruby/object:Gem::Dependency 
-  name: mocha
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  name: contest
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
         version: "0"
-    version: 
-description: uses sorted sets and sets, sorting by score
+  type: :development
+  version_requirements: *id004
+description: Features full text searching via metaphones, range querying for numbers, fuzzy searching and sorting based on customer fields
 email: cyx.ucron@gmail.com
 executables: []
 
@@ -40,66 +77,33 @@ extensions: []
 
 extra_rdoc_files: 
 - LICENSE
-- README.md
+- README.markdown
 files: 
-- .document
 - .gitignore
-- DATA
 - LICENSE
-- README.md
+- README.markdown
 - Rakefile
 - VERSION
-- examples/ohm.rb
 - lib/lunar.rb
+- lib/lunar/connection.rb
+- lib/lunar/fuzzy_matches.rb
 - lib/lunar/fuzzy_word.rb
 - lib/lunar/index.rb
+- lib/lunar/keyword_matches.rb
+- lib/lunar/lunar_nest.rb
+- lib/lunar/range_matches.rb
 - lib/lunar/result_set.rb
 - lib/lunar/scoring.rb
-- lib/lunar/search.rb
-- lib/lunar/sets.rb
+- lib/lunar/stopwords.rb
 - lib/lunar/words.rb
 - lunar.gemspec
 - test/helper.rb
+- test/test_fuzzy_indexing.rb
+- test/test_index.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
-- test/test_sets.rb
-- vendor/nest/nest.rb
-- vendor/redis/.gitignore
-- vendor/redis/LICENSE
-- vendor/redis/README.markdown
-- vendor/redis/Rakefile
-- vendor/redis/benchmarking/logging.rb
-- vendor/redis/benchmarking/pipeline.rb
-- vendor/redis/benchmarking/speed.rb
-- vendor/redis/benchmarking/suite.rb
-- vendor/redis/benchmarking/worker.rb
-- vendor/redis/bin/distredis
-- vendor/redis/examples/basic.rb
-- vendor/redis/examples/dist_redis.rb
-- vendor/redis/examples/incr-decr.rb
-- vendor/redis/examples/list.rb
-- vendor/redis/examples/pubsub.rb
-- vendor/redis/examples/sets.rb
-- vendor/redis/lib/edis.rb
-- vendor/redis/lib/redis.rb
-- vendor/redis/lib/redis/client.rb
-- vendor/redis/lib/redis/dist_redis.rb
-- vendor/redis/lib/redis/distributed.rb
-- vendor/redis/lib/redis/hash_ring.rb
-- vendor/redis/lib/redis/pipeline.rb
-- vendor/redis/lib/redis/raketasks.rb
-- vendor/redis/lib/redis/subscribe.rb
-- vendor/redis/profile.rb
-- vendor/redis/tasks/redis.tasks.rb
-- vendor/redis/test/db/.gitignore
-- vendor/redis/test/distributed_test.rb
-- vendor/redis/test/redis_test.rb
-- vendor/redis/test/test.conf
-- vendor/redis/test/test_helper.rb
+- test/test_lunar_nest.rb
+- test/test_scoring.rb
 has_rdoc: true
 homepage: http://github.com/sinefunc/lunar
 licenses: []
@@ -113,28 +117,28 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
-summary: a minimalistic full text search implementation in redis
+summary: A redis based full text search engine
 test_files: 
 - test/helper.rb
+- test/test_fuzzy_indexing.rb
+- test/test_index.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
-- test/test_sets.rb
-- examples/ohm.rb
+- test/test_lunar_nest.rb
+- test/test_scoring.rb