picky 3.5.4 → 3.6.0

data/spec/lib/backends/sqlite_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+
+describe Picky::Backends::Sqlite do
+
+  context 'with options' do
+    before(:each) do
+      @backend = described_class.new inverted:      Picky::Backends::Sqlite::DB.new(:unimportant),
+                                     weights:       Picky::Backends::Sqlite::DB.new(:unimportant),
+                                     similarity:    Picky::Backends::Sqlite::DB.new(:unimportant),
+                                     configuration: Picky::Backends::Sqlite::DB.new(:unimportant)
+
+      @backend.stub! :timed_exclaim
+    end
+  
+    describe 'create_...' do
+      [
+        [:inverted,      Picky::Backends::Sqlite::DB],
+        [:weights,       Picky::Backends::Sqlite::DB],
+        [:similarity,    Picky::Backends::Sqlite::DB],
+        [:configuration, Picky::Backends::Sqlite::DB]
+      ].each do |type, kind|
+        it "creates and returns a(n) #{type} index" do
+          @backend.send(:"create_#{type}",
+                        stub(type, :index_path => "spec/test_directory/index/test/some_index/some_category_some_bundle_#{type}")
+          ).should be_kind_of(kind)
+        end
+      end
+    end
+  end
+  
+  context 'with lambda options' do
+    before(:each) do
+      @backend = described_class.new inverted:      ->(bundle){ Picky::Backends::Sqlite::DB.new(bundle.index_path(:inverted)) },
+                                     weights:       ->(bundle){ Picky::Backends::Sqlite::DB.new(bundle.index_path(:weights)) },
+                                     similarity:    ->(bundle){ Picky::Backends::Sqlite::DB.new(bundle.index_path(:similarity)) },
+                                     configuration: ->(bundle){ Picky::Backends::Sqlite::DB.new(bundle.index_path(:configuration)) }
+
+      @backend.stub! :timed_exclaim
+    end
+  
+    describe 'create_...' do
+      [
+        [:inverted,      Picky::Backends::Sqlite::DB],
+        [:weights,       Picky::Backends::Sqlite::DB],
+        [:similarity,    Picky::Backends::Sqlite::DB],
+        [:configuration, Picky::Backends::Sqlite::DB]
+      ].each do |type, kind|
+        it "creates and returns a(n) #{type} index" do
+          to_a_able_stub = Object.new
+          to_a_able_stub.stub! :index_path => "spec/test_directory/index/test/some_index/some_category_some_bundle_#{type}"
+          @backend.send(:"create_#{type}", to_a_able_stub).should be_kind_of(kind)
+        end
+      end
+    end
+  end
+
+  context 'without options' do
+    before(:each) do
+      @backend = described_class.new
+
+      @backend.stub! :timed_exclaim
+    end
+  
+    describe 'create_...' do
+      [
+        [:inverted,      Picky::Backends::Sqlite::DB],
+        [:weights,       Picky::Backends::Sqlite::DB],
+        [:similarity,    Picky::Backends::Sqlite::DB],
+        [:configuration, Picky::Backends::Sqlite::DB]
+      ].each do |type, kind|
+        it "creates and returns a(n) #{type} index" do
+          @backend.send(:"create_#{type}",
+                        stub(type, :index_path => "spec/test_directory/index/test/some_index/some_category_some_bundle_#{type}")
+          ).should be_kind_of(kind)
+        end
+      end
+    end
+  
+    describe "ids" do
+      before(:each) do
+        @combination1 = stub :combination1
+        @combination2 = stub :combination2
+        @combination3 = stub :combination3
+        @combinations = [@combination1, @combination2, @combination3]
+      end
+      it "should intersect correctly" do
+        @combination1.should_receive(:ids).once.with.and_return (1..100_000).to_a
+        @combination2.should_receive(:ids).once.with.and_return (1..100).to_a
+        @combination3.should_receive(:ids).once.with.and_return (1..10).to_a
+
+        @backend.ids(@combinations, :any, :thing).should == (1..10).to_a
+      end
+      it "should intersect symbol_keys correctly" do
+        @combination1.should_receive(:ids).once.with.and_return (:'00001'..:'10000').to_a
+        @combination2.should_receive(:ids).once.with.and_return (:'00001'..:'00100').to_a
+        @combination3.should_receive(:ids).once.with.and_return (:'00001'..:'00010').to_a
+
+        @backend.ids(@combinations, :any, :thing).should == (:'00001'..:'0010').to_a
+      end
+      it "should intersect correctly when intermediate intersect result is empty" do
+        @combination1.should_receive(:ids).once.with.and_return (1..100_000).to_a
+        @combination2.should_receive(:ids).once.with.and_return (11..100).to_a
+        @combination3.should_receive(:ids).once.with.and_return (1..10).to_a
+
+        @backend.ids(@combinations, :any, :thing).should == []
+      end
+      it "should be fast" do
+        @combination1.should_receive(:ids).once.with.and_return (1..100_000).to_a
+        @combination2.should_receive(:ids).once.with.and_return (1..100).to_a
+        @combination3.should_receive(:ids).once.with.and_return (1..10).to_a
+
+        performance_of { @backend.ids(@combinations, :any, :thing) }.should < 0.004
+      end
+      it "should be fast" do
+        @combination1.should_receive(:ids).once.with.and_return (1..1000).to_a
+        @combination2.should_receive(:ids).once.with.and_return (1..100).to_a
+        @combination3.should_receive(:ids).once.with.and_return (1..10).to_a
+
+        performance_of { @backend.ids(@combinations, :any, :thing) }.should < 0.00015
+      end
+      it "should be fast" do
+        @combination1.should_receive(:ids).once.with.and_return (1..1000).to_a
+        @combination2.should_receive(:ids).once.with.and_return (901..1000).to_a
+        @combination3.should_receive(:ids).once.with.and_return (1..10).to_a
+
+        performance_of { @backend.ids(@combinations, :any, :thing) }.should < 0.0001
+      end
+    end
+  end
+
+end

data/spec/lib/category_indexed_spec.rb

@@ -158,13 +158,13 @@ describe Picky::Category do
       end
     end
 
-    describe 'load_from_cache' do
+    describe 'load' do
       it 'should call two methods' do
         @category.should_receive(:clear_realtime_mapping).once
         @exact.should_receive(:load).once
         @partial.should_receive(:load).once
 
-        @category.load_from_cache
+        @category.load
       end
     end
   end

data/spec/lib/category_indexing_spec.rb

@@ -12,30 +12,6 @@ describe Picky::Category do
     let(:exact) { category.exact }
     let(:partial) { category.partial }
 
-    describe 'backup' do
-      it 'delegates to both bundles' do
-        exact.should_receive(:backup).once.with()
-        partial.should_receive(:backup).once.with()
-
-        category.backup
-      end
-    end
-    describe 'restore' do
-      it 'delegates to both bundles' do
-        exact.should_receive(:restore).once.with()
-        partial.should_receive(:restore).once.with()
-
-        category.restore
-      end
-    end
-    describe 'check' do
-      it 'delegates to both bundles' do
-        exact.should_receive(:raise_unless_cache_exists).once.with()
-        partial.should_receive(:raise_unless_cache_exists).once.with()
-
-        category.check
-      end
-    end
     describe 'clear' do
       it 'delegates to both bundles' do
         exact.should_receive(:delete).once.with()

data/spec/lib/extensions/string_spec.rb

@@ -17,6 +17,22 @@ describe String do
     end
   end
 
+  describe 'double_metaphone' do
+    it 'returns the right code' do
+      'hello'.double_metaphone.should == 'HL'
+    end
+  end
+  describe 'metaphone' do
+    it 'returns the right code' do
+      'hello'.metaphone.should == 'HL'
+    end
+  end
+  describe 'soundex' do
+    it 'returns the right code' do
+      'hello'.soundex.should == 'H400'
+    end
+  end
+
   describe 'each_intoken' do
     context 'normal String' do
       before(:each) do

data/spec/lib/extensions/symbol_spec.rb

@@ -17,6 +17,22 @@ describe Symbol do
     end
   end
 
+  describe 'double_metaphone' do
+    it 'returns the right code' do
+      :hello.double_metaphone.should == :HL
+    end
+  end
+  describe 'metaphone' do
+    it 'returns the right code' do
+      :hello.metaphone.should == :HL
+    end
+  end
+  describe 'soundex' do
+    it 'returns the right code' do
+      :hello.soundex.should == :H400
+    end
+  end
+
   describe 'each_intoken' do
     context 'normal symbol' do
       before(:each) do

data/spec/lib/index_indexed_spec.rb

@@ -1,51 +1,51 @@
 require 'spec_helper'
 
 describe Picky::Index do
-  
+
   context 'without stubbed categories' do
     before(:each) do
       @index = described_class.new :some_index_name
     end
-    
+
     describe 'define_category' do
       it 'adds a new category to the categories' do
         @index.define_category :some_category_name
-        
-        @index.categories.categories.size.should == 1 
+
+        @index.categories.categories.size.should == 1
       end
       it 'returns the new category' do
         @index.define_category(:some_category_name).should be_kind_of(Picky::Category)
       end
     end
   end
-  
+
   context "with stubbed categories" do
     before(:each) do
       @categories = stub :categories
-      
+
       @index = described_class.new :some_name
       @index.define_category :some_category_name1
       @index.define_category :some_category_name2
-      
+
       @index.stub! :categories => @categories
     end
-    
-    describe "load_from_cache" do
+
+    describe "load" do
       it "delegates to each category" do
-        @categories.should_receive(:load_from_cache).once.with
-        
-        @index.load_from_cache
+        @categories.should_receive(:load).once.with
+
+        @index.load
       end
     end
     describe "possible_combinations" do
       it "delegates to the combinator" do
         @categories.should_receive(:possible_combinations).once.with :some_token
-        
+
         @index.possible_combinations :some_token
       end
     end
   end
-  
+
   context 'result_identifier' do
     context 'with it set' do
       let(:index) do
@@ -67,11 +67,11 @@ describe Picky::Index do
       end
     end
   end
-  
+
   context "no categories" do
     it "works" do
       described_class.new :some_name
     end
   end
-  
+
 end

data/spec/lib/indexes_indexed_spec.rb

@@ -11,7 +11,7 @@ describe Picky::Indexes do
       indexes.indexes.should == []
     end
   end
-  
+
   describe 'methods' do
     let(:indexes) { described_class.new }
     before(:each) do
@@ -39,23 +39,29 @@ describe Picky::Indexes do
     describe 'clear' do
       it 'clears the indexes' do
         indexes.clear_indexes
-        
+
         indexes.indexes.should == []
       end
       it 'clears the mapping' do
         indexes.clear_indexes
-        
+
         indexes.index_mapping.should == {}
       end
     end
     describe 'reload' do
-      it 'calls load_from_cache on each in order' do
-        @index1.should_receive(:load_from_cache).once.with.ordered
-        @index2.should_receive(:load_from_cache).once.with.ordered
+      it 'calls load on each in order' do
+        @index1.should_receive(:reload).once.with.ordered
+        @index2.should_receive(:reload).once.with.ordered
 
         indexes.reload
       end
+      it 'is aliased' do
+        @index1.should_receive(:load).once.with.ordered
+        @index2.should_receive(:load).once.with.ordered
+
+        indexes.load
+      end
     end
   end
-  
+
 end

data/spec/lib/indexes_indexing_spec.rb

@@ -23,7 +23,7 @@ describe Picky::Indexes do
       it 'takes a snapshot, then indexes and caches each' do
         @index1.should_receive(:index).once.with.ordered
         @index2.should_receive(:index).once.with.ordered
-      
+
         indexes.index_for_tests
       end
     end
@@ -35,7 +35,7 @@ describe Picky::Indexes do
     describe 'clear_indexes' do
       it 'clears the indexes' do
         indexes.clear_indexes
-      
+
         indexes.indexes.should == []
       end
     end
@@ -49,10 +49,7 @@ describe Picky::Indexes do
         end
       end
     end
-    it_delegates_each :check
     it_delegates_each :clear
-    it_delegates_each :backup
-    it_delegates_each :restore
   end
-  
+
 end

data/spec/lib/indexing/bundle_spec.rb

@@ -35,22 +35,6 @@ describe Picky::Bundle do
     end
   end
 
-  describe 'raise_cache_missing' do
-    it 'does something' do
-      expect {
-        bundle.raise_cache_missing :similarity
-      }.to raise_error("Error: The similarity cache for some_index:some_category:some_name is missing.")
-    end
-  end
-
-  describe 'warn_cache_small' do
-    it 'warns the user' do
-      bundle.should_receive(:warn).once.with "Warning: similarity cache for some_index:some_category:some_name smaller than 16 bytes."
-
-      bundle.warn_cache_small :similarity
-    end
-  end
-
   describe 'identifier' do
     it 'should return a specific identifier' do
       bundle.identifier.should == 'some_index:some_category:some_name'
@@ -70,110 +54,7 @@ describe Picky::Bundle do
     end
   end
 
-  describe 'raise_unless_cache_exists' do
-    it "calls methods in order" do
-      bundle.should_receive(:raise_unless_index_exists).once.ordered
-      bundle.should_receive(:raise_unless_similarity_exists).once.ordered
-
-      bundle.raise_unless_cache_exists
-    end
-  end
-  describe 'raise_unless_index_exists' do
-    context 'partial strategy saved' do
-      before(:each) do
-        strategy = stub :strategy, :saved? => true
-        bundle.stub! :partial_strategy => strategy
-      end
-      it "calls the methods in order" do
-        bundle.should_receive(:warn_if_index_small).once.ordered
-        bundle.should_receive(:raise_unless_index_ok).once.ordered
-
-        bundle.raise_unless_index_exists
-      end
-    end
-    context 'partial strategy not saved' do
-      before(:each) do
-        strategy = stub :strategy, :saved? => false
-        bundle.stub! :partial_strategy => strategy
-      end
-      it "calls nothing" do
-        bundle.should_receive(:warn_if_index_small).never
-        bundle.should_receive(:raise_unless_index_ok).never
-
-        bundle.raise_unless_index_exists
-      end
-    end
-  end
-  describe 'raise_unless_similarity_exists' do
-    context 'similarity strategy saved' do
-      before(:each) do
-        strategy = stub :strategy, :saved? => true
-        bundle.stub! :similarity_strategy => strategy
-      end
-      it "calls the methods in order" do
-        bundle.should_receive(:warn_if_similarity_small).once.ordered
-        bundle.should_receive(:raise_unless_similarity_ok).once.ordered
 
-        bundle.raise_unless_similarity_exists
-      end
-    end
-    context 'similarity strategy not saved' do
-      before(:each) do
-        strategy = stub :strategy, :saved? => false
-        bundle.stub! :similarity_strategy => strategy
-      end
-      it "calls nothing" do
-        bundle.should_receive(:warn_if_similarity_small).never
-        bundle.should_receive(:raise_unless_similarity_ok).never
-
-        bundle.raise_unless_similarity_exists
-      end
-    end
-  end
-  describe 'warn_if_similarity_small' do
-    context "files similarity cache small" do
-      before(:each) do
-        bundle.stub! :backend_similarity => stub(:backend_similarity, :cache_small? => true)
-      end
-      it "warns" do
-        bundle.should_receive(:warn_cache_small).once.with :similarity
-
-        bundle.warn_if_similarity_small
-      end
-    end
-    context "files similarity cache not small" do
-      before(:each) do
-        bundle.stub! :backend_similarity => stub(:backend_similarity, :cache_small? => false)
-      end
-      it "does not warn" do
-        bundle.should_receive(:warn_cache_small).never
-
-        bundle.warn_if_similarity_small
-      end
-    end
-  end
-  describe 'raise_unless_similarity_ok' do
-    context "files similarity cache ok" do
-      before(:each) do
-        bundle.stub! :backend_similarity => stub(:backend_similarity, :cache_ok? => true)
-      end
-      it "warns" do
-        bundle.should_receive(:raise_cache_missing).never
-
-        bundle.raise_unless_similarity_ok
-      end
-    end
-    context "files similarity cache not ok" do
-      before(:each) do
-        bundle.stub! :backend_similarity => stub(:backend_similarity, :cache_ok? => false)
-      end
-      it "does not warn" do
-        bundle.should_receive(:raise_cache_missing).once.with :similarity
-
-        bundle.raise_unless_similarity_ok
-      end
-    end
-  end
 
   describe 'initialization' do
     it 'should initialize the index correctly' do
@@ -188,12 +69,12 @@ describe Picky::Bundle do
     it 'should initialize the configuration correctly' do
       bundle.configuration.should == {}
     end
-    # it 'should initialize the partial strategy correctly' do
-    #   bundle.partial_strategy.should == @partial
-    # end
-    # it 'should initialize the weights strategy correctly' do
-    #   bundle.weights_strategy.should == @weights
-    # end
+    it 'should initialize the partial strategy correctly' do
+      bundle.partial_strategy.should == :some_partial
+    end
+    it 'should initialize the weights strategy correctly' do
+      bundle.weights_strategy.should == @weights
+    end
     it 'should initialize the similarity strategy correctly' do
       bundle.similarity_strategy.should == @similarity
     end

data/spec/lib/sources/couch_spec.rb

@@ -1,12 +1,12 @@
 require 'spec_helper'
 
 describe Picky::Sources::Couch do
-  
+
   describe 'key_format' do
     context 'default' do
       let(:source) { described_class.new(:a, :b, url: 'bla') }
       it 'is correct' do
-        source.key_format.should == :to_sym
+        source.key_format.should == :to_s
       end
     end
     context 'non-default' do
@@ -16,14 +16,14 @@ describe Picky::Sources::Couch do
       end
     end
   end
-  
+
   describe 'to_s' do
     let(:source) { described_class.new(:a, :b, :url => 'bla') }
     it 'is correct' do
       source.to_s.should == 'Picky::Sources::Couch'
     end
   end
-  
+
   describe 'special keys' do
     context 'uuid keys' do
       context "with database" do
@@ -36,7 +36,7 @@ describe Picky::Sources::Couch do
           it "yields the right data" do
             category = stub :b, :from => :b
             @source.harvest category do |id, token|
-              id.should    eql('550e8400-e29b-41d4-a716-446655440000') 
+              id.should    eql('550e8400-e29b-41d4-a716-446655440000')
               token.should eql('b data')
             end.should have(1).item
           end
@@ -62,7 +62,7 @@ describe Picky::Sources::Couch do
           it "yields the right data" do
             category = stub :b, :from => :b
             @source.harvest category do |id, token|
-              id.should    eql('123') 
+              id.should    eql('123')
               token.should eql('b data')
             end.should have(1).item
           end
@@ -78,7 +78,7 @@ describe Picky::Sources::Couch do
       end
     end
   end
-  
+
   context 'default keys' do
     context "without database" do
       it "should fail correctly" do
@@ -96,7 +96,7 @@ describe Picky::Sources::Couch do
         it "yields the right data" do
           category = stub :b, :from => :b
           @source.harvest category do |id, token|
-            id.should    eql('7f') 
+            id.should    eql('7f')
             token.should eql('b data')
           end.should have(1).item
         end

data/spec/lib/sources/mongo_spec.rb

@@ -1,12 +1,12 @@
 require 'spec_helper'
 
 describe Picky::Sources::Mongo do
-  
+
   describe 'key_format' do
     context 'default' do
       let(:source) { described_class.new(:a, :b, :url => 'someurl', :db => 'somedb') }
       it 'is correct' do
-        source.key_format.should == :to_sym
+        source.key_format.should == :to_s
       end
     end
 
@@ -17,14 +17,14 @@ describe Picky::Sources::Mongo do
       end
     end
   end
-  
+
   describe 'to_s' do
      let(:source) { described_class.new(:a, :b, :url => 'someurl', :db => 'somedb') }
      it 'is correct' do
        source.to_s.should == 'Picky::Sources::Mongo'
      end
    end
-   
+
    context "without database" do
      it "should fail correctly" do
        lambda { @source = described_class.new(:a, :b, :url => 'someurl') }.should raise_error(described_class::NoDBGiven)
@@ -41,7 +41,7 @@ describe Picky::Sources::Mongo do
        it "yields the right data" do
          category = stub :b, :from => :b, :index_name => :some_index_name
          @source.harvest category do |id, token|
-           id.should    eql('7f') 
+           id.should    eql('7f')
            token.should eql('b data')
          end.should have(1).item
        end